@agentlayer.tech/wallet 0.1.72 → 0.1.74

package/bin/openclaw-agent-wallet.mjs

@@ -380,6 +380,69 @@ function releaseRootFor(version, env = process.env) {
   return path.join(resolveRuntimeBase(env), "releases", version);
 }
 
+function stagingRootFor(version, env = process.env) {
+  return path.join(
+    resolveRuntimeBase(env),
+    "releases",
+    `.staging-${version}-${process.pid}-${Date.now()}`,
+  );
+}
+
+function updateJournalPath(env = process.env) {
+  return path.join(resolveRuntimeBase(env), "update-journal.json");
+}
+
+function writeUpdateJournal(state, details = {}, env = process.env) {
+  writeJsonFile(updateJournalPath(env), {
+    schema_version: 1,
+    state,
+    version: packageVersion,
+    updated_at: new Date().toISOString(),
+    ...details,
+  });
+}
+
+function writeReleaseState(runtimeRoot, state, details = {}) {
+  writeJsonFile(path.join(runtimeRoot, ".agent-wallet-release.json"), {
+    schema_version: 1,
+    version: packageVersion,
+    state,
+    updated_at: new Date().toISOString(),
+    ...details,
+  });
+}
+
+function failStagingRuntime(stagingRoot, error) {
+  if (!stagingRoot || !fs.existsSync(stagingRoot)) return null;
+  writeReleaseState(stagingRoot, "failed", { error: String(error || "install failed") });
+  const failedRoot = path.join(
+    path.dirname(stagingRoot),
+    `.failed-${packageVersion}-${Date.now()}`,
+  );
+  fs.renameSync(stagingRoot, failedRoot);
+  return failedRoot;
+}
+
+function commitStagedRuntime(stagingRoot, releaseRoot) {
+  if (!stagingRoot) return null;
+  let replacedRoot = null;
+  if (fs.existsSync(releaseRoot)) {
+    replacedRoot = uniquePathWithSuffix(
+      path.join(path.dirname(releaseRoot), `${path.basename(releaseRoot)}-replaced`),
+    );
+    fs.renameSync(releaseRoot, replacedRoot);
+  }
+  try {
+    fs.renameSync(stagingRoot, releaseRoot);
+  } catch (error) {
+    if (replacedRoot && !fs.existsSync(releaseRoot)) {
+      fs.renameSync(replacedRoot, releaseRoot);
+    }
+    throw error;
+  }
+  return replacedRoot;
+}
+
 function currentRuntimePath(env = process.env) {
   return path.join(resolveRuntimeBase(env), "current");
 }
@@ -507,7 +570,21 @@ function listReleases(env = process.env) {
   try {
     return fs
       .readdirSync(releasesDir, { withFileTypes: true })
-      .filter((entry) => entry.isDirectory())
+      .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
+      .map((entry) => entry.name)
+      .sort();
+  } catch (error) {
+    if (error?.code === "ENOENT") return [];
+    throw error;
+  }
+}
+
+function listFailedReleases(env = process.env) {
+  const releasesDir = path.join(resolveRuntimeBase(env), "releases");
+  try {
+    return fs
+      .readdirSync(releasesDir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && entry.name.startsWith(".failed-"))
       .map((entry) => entry.name)
       .sort();
   } catch (error) {
@@ -944,6 +1021,44 @@ function readBootKeyFromKeystore(env = process.env) {
   }
 }
 
+// New runtimes own boot-key precedence and verify candidates against
+// sealed_keys.json. An import failure means the active runtime predates this
+// bridge, so callers may use the legacy JS fallback below.
+function readBootKeyFromRuntimeResolver(env = process.env) {
+  const runtimeRoot = resolvedCurrentRuntimeRoot(env);
+  if (!runtimeRoot) return { supported: false, key: "" };
+  const py = resolveVenvPython(runtimeRoot);
+  if (!py) return { supported: false, key: "" };
+  try {
+    const res = spawnSync(
+      py,
+      ["-c", "from agent_wallet.config import resolve_boot_key_for_installer as r; print(r())"],
+      {
+        cwd: path.join(runtimeRoot, "agent-wallet"),
+        encoding: "utf8",
+        timeout: positiveIntEnv("AGENT_WALLET_KEYSTORE_BRIDGE_TIMEOUT_MS", KEYSTORE_BRIDGE_TIMEOUT_MS, env),
+        env: { ...env, OPENCLAW_HOME: resolveOpenclawHome(env) },
+      },
+    );
+    if ((res.status ?? 1) !== 0) return { supported: false, key: "" };
+    return { supported: true, key: String(res.stdout || "").trim() };
+  } catch {
+    return { supported: false, key: "" };
+  }
+}
+
+function resolveLegacyInstallerBootKey(env = process.env) {
+  for (const [source, key] of [
+    ["legacy_keystore", readBootKeyFromKeystore(env)],
+    ["current_runtime_env", currentBootKey(env)],
+    ["configured_file", resolveBootKeyFromFile(env)],
+    ["default_file", readTextIfExists(defaultBootKeyFile(env)).trim()],
+  ]) {
+    if (key) return { key, source };
+  }
+  return { key: "", source: "none" };
+}
+
 // Provision the boot key into the OS keystore via the freshly installed runtime's
 // Python. Returns true only when the import stored AND verified the key, so the
 // caller may safely drop the plaintext .env copy. Best-effort: false on any failure
@@ -1218,6 +1333,7 @@ function runStatus(args = []) {
     previous_runtime: readLinkOrNull(previousRuntimePath()),
     active_version: activeVersion(),
     available_releases: listReleases(),
+    failed_releases: listFailedReleases(),
     update_available: computeUpdateAvailability(),
     runtime_in_sync: computeRuntimeInSync(),
   };
@@ -1236,12 +1352,17 @@ function buildInstallerEnv(args) {
   const sealedKeysPath = path.join(resolveOpenclawHome(env), "sealed_keys.json");
   const sealedKeysExist = fs.existsSync(sealedKeysPath);
   const dryRun = hasFlag(args, "--dry-run");
+  let bootKeySource = env.AGENT_WALLET_BOOT_KEY ? "environment" : "none";
   if (!env.AGENT_WALLET_BOOT_KEY) {
-    const existingBootKey =
-      resolveBootKeyFromFile(env) ||
-      readTextIfExists(defaultBootKeyFile(env)).trim() ||
-      currentBootKey(env) ||
-      readBootKeyFromKeystore(env);
+    const runtimeResolution = readBootKeyFromRuntimeResolver(env);
+    const fallback = runtimeResolution.supported
+      ? {
+          key: runtimeResolution.key,
+          source: runtimeResolution.key ? "runtime_verified" : "runtime_rejected",
+        }
+      : resolveLegacyInstallerBootKey(env);
+    const existingBootKey = fallback.key;
+    bootKeySource = fallback.source;
     if (existingBootKey) {
       env.AGENT_WALLET_BOOT_KEY = existingBootKey;
     }
@@ -1261,6 +1382,7 @@ function buildInstallerEnv(args) {
   if (!sealedKeysExist && shouldGenerateSecrets && !env.AGENT_WALLET_BOOT_KEY) {
     generated.AGENT_WALLET_BOOT_KEY = token();
     env.AGENT_WALLET_BOOT_KEY = generated.AGENT_WALLET_BOOT_KEY;
+    bootKeySource = "generated";
   }
   if (!sealedKeysExist && shouldGenerateSecrets && !env.AGENT_WALLET_MASTER_KEY) {
     generated.AGENT_WALLET_MASTER_KEY = token();
@@ -1270,7 +1392,7 @@ function buildInstallerEnv(args) {
     generated.AGENT_WALLET_APPROVAL_SECRET = token();
     env.AGENT_WALLET_APPROVAL_SECRET = generated.AGENT_WALLET_APPROVAL_SECRET;
   }
-  return { env, generated };
+  return { env, generated, bootKeySource };
 }
 
 function runInstall(args, { commandName = "install" } = {}) {
@@ -1287,9 +1409,11 @@ function runInstall(args, { commandName = "install" } = {}) {
   const previousPath = previousRuntimePath();
   const installerArgs = withoutCliOnlyArgs(args);
   const dryRun = hasFlag(args, "--dry-run");
+  const stagingRoot = !explicitRuntimeRoot && !dryRun ? stagingRootFor(packageVersion) : null;
+  const installRoot = stagingRoot || releaseRoot;
 
   if (!hasFlag(installerArgs, "--runtime-root")) {
-    installerArgs.push("--runtime-root", releaseRoot);
+    installerArgs.push("--runtime-root", installRoot);
   }
   if (!hasFlag(installerArgs, "--install-from-runtime")) {
     installerArgs.push("--install-from-runtime");
@@ -1302,7 +1426,11 @@ function runInstall(args, { commandName = "install" } = {}) {
     console.error(error.message);
     return 1;
   }
-  const { env, generated } = installerEnv;
+  const { env, generated, bootKeySource } = installerEnv;
+  if (stagingRoot) {
+    env.OPENCLAW_INSTALL_FINAL_ROOT = releaseRoot;
+    writeUpdateJournal("preparing", { staging_root: stagingRoot, release_root: releaseRoot }, env);
+  }
   const result = spawnSync("sh", [setupPath, ...installerArgs], {
     cwd: packageRoot,
     stdio: "inherit",
@@ -1310,10 +1438,22 @@ function runInstall(args, { commandName = "install" } = {}) {
   });
 
   if (result.error) {
+    const failedRoot = failStagingRuntime(stagingRoot, result.error.message);
+    if (!dryRun) {
+      writeUpdateJournal("failed", { failed_runtime: failedRoot, error: result.error.message }, env);
+    }
     console.error(result.error.message);
     return 1;
   }
   if ((result.status ?? 1) !== 0) {
+    const failedRoot = failStagingRuntime(stagingRoot, `installer exited with ${result.status ?? 1}`);
+    if (!dryRun) {
+      writeUpdateJournal(
+        "failed",
+        { failed_runtime: failedRoot, error: `installer exited with ${result.status ?? 1}` },
+        env,
+      );
+    }
     return result.status ?? 1;
   }
 
@@ -1321,34 +1461,21 @@ function runInstall(args, { commandName = "install" } = {}) {
     return 0;
   }
 
-  const currentTarget = existingRuntimePointerTarget(currentPath);
-  if (currentTarget) {
-    switchSymlink(previousPath, currentTarget);
-  }
-  switchSymlink(currentPath, releaseRoot);
-
   // Installs that pass --skip-python-setup may have no venv, so this handshake
   // would fail and trigger a spurious rollback; such flows must set
   // AGENT_WALLET_VERIFY_DISABLE=1 (verifyRuntime then skips).
-  const verification = verifyRuntime(releaseRoot, env);
+  const currentTarget = existingRuntimePointerTarget(currentPath);
+  const verification = verifyRuntime(installRoot, env);
   if (!verification.ok && !verification.skipped) {
-    const rollbackTarget = currentTarget; // pre-switch target captured before the switch, if any
-    const rolledBack = Boolean(rollbackTarget);
-    if (rolledBack) {
-      switchSymlink(currentPath, rollbackTarget);
-    }
+    const failedRoot = failStagingRuntime(stagingRoot, verification.error);
+    const rolledBack = Boolean(currentTarget);
     const previousVersion = rolledBack
-      ? path.basename(path.resolve(path.dirname(currentPath), rollbackTarget))
+      ? path.basename(currentTarget)
       : null;
 
     let human;
     let fix;
     if (!rolledBack) {
-      // First install / no good fallback — leave no active runtime rather than a
-      // broken one. Deliberately do NOT point `previous` at the broken release,
-      // so a later `rollback` cannot reactivate it; the release stays under
-      // releases/<version> for inspection via `install --version`.
-      removeRuntimePointer(currentPath);
       human =
         verification.category === "broken_release"
           ? `Release ${packageVersion} is broken and there is no previous working version to fall back to. Nothing is active. This is a bad release — please report it; a patched version will follow.`
@@ -1377,7 +1504,9 @@ function runInstall(args, { commandName = "install" } = {}) {
           category: verification.category || "unknown",
           error: `runtime verification failed: ${verification.error}`,
           rolled_back: rolledBack,
+          switched_current: false,
           kept_version: previousVersion,
+          failed_runtime: failedRoot,
           current_runtime_target: readLinkOrNull(currentPath),
           message: human,
           fix,
@@ -1386,15 +1515,20 @@ function runInstall(args, { commandName = "install" } = {}) {
         2,
       ),
     );
+    writeUpdateJournal(
+      "failed",
+      { failed_runtime: failedRoot, error: verification.error, kept_version: previousVersion },
+      env,
+    );
     return 1;
   }
 
   if (env.AGENT_WALLET_BOOT_KEY) {
-    const envPath = path.join(releaseRoot, "agent-wallet", ".env");
+    const envPath = path.join(installRoot, "agent-wallet", ".env");
     // Prefer the OS keystore: provision the boot key there and keep the plaintext
     // out of the release .env entirely. Only fall back to the legacy .env write when
     // no keystore round-trip is possible, so the runtime can still resolve the key.
-    if (provisionBootKeyToKeystore(releaseRoot, env, env.AGENT_WALLET_BOOT_KEY)) {
+    if (provisionBootKeyToKeystore(installRoot, env, env.AGENT_WALLET_BOOT_KEY)) {
       envFileUnset(envPath, ["AGENT_WALLET_BOOT_KEY"]);
     } else {
       envFileSet(envPath, {
@@ -1403,7 +1537,32 @@ function runInstall(args, { commandName = "install" } = {}) {
     }
   }
 
-  const integrationRefresh = refreshInstalledEditorIntegrations(env);
+  writeReleaseState(installRoot, "verified", {
+    verification_skipped: Boolean(verification.skipped),
+  });
+  writeUpdateJournal("verified", { staging_root: stagingRoot, release_root: releaseRoot }, env);
+
+  let replacedRoot = null;
+  try {
+    replacedRoot = commitStagedRuntime(stagingRoot, releaseRoot);
+  } catch (error) {
+    const failedRoot = failStagingRuntime(stagingRoot, error.message);
+    writeUpdateJournal("failed", { failed_runtime: failedRoot, error: error.message }, env);
+    console.error(`Could not commit staged runtime: ${error.message}`);
+    return 1;
+  }
+
+  const previousTarget =
+    currentTarget && path.resolve(currentTarget) === path.resolve(releaseRoot) && replacedRoot
+      ? replacedRoot
+      : currentTarget;
+  if (previousTarget) {
+    switchSymlink(previousPath, previousTarget);
+  }
+  switchSymlink(currentPath, releaseRoot);
+  writeUpdateJournal("committed", { release_root: releaseRoot, previous_runtime: previousTarget }, env);
+
+  const integrationRefresh = repairInstalledEditorIntegrations(env);
 
   const pythonInfo = activePythonRuntimeInfo(env);
   const nodeInfo = activeNodeRuntimeInfo(env)
@@ -1423,6 +1582,9 @@ function runInstall(args, { commandName = "install" } = {}) {
         current_runtime: currentPath,
         previous_runtime: readLinkOrNull(previousPath),
         generated_runtime_secrets: Object.keys(generated),
+        boot_key_source: bootKeySource,
+        staged: Boolean(stagingRoot),
+        release_state: "verified",
         integration_refresh: integrationRefresh,
       },
       null,
@@ -1864,7 +2026,7 @@ function runHermesInstall(args) {
 function runCodexInstall(args) {
   const codexHome = resolveCodexHome();
   const pluginSource = resolveCodexPluginSource();
-  const pinnedEnv = pinEditorMcpEnv(pluginSource);
+  const pinnedEnv = { pinned: false, reason: "plugin source is immutable" };
   const pluginRoot = resolveCodexPluginInstallRoot();
   const pluginTarget = path.join(pluginRoot, "agent-wallet");
   const marketplacePath = resolveCodexMarketplacePath();
@@ -1986,10 +2148,6 @@ function pinHomeIntoMcpFile(mcpPath, env = process.env) {
   return { pinned: true, openclaw_home: home, path: mcpPath };
 }
 
-function pinEditorMcpEnv(pluginSource, env = process.env) {
-  return pinHomeIntoMcpFile(path.join(pluginSource, ".mcp.json"), env);
-}
-
 // Claude Code copies the plugin into a version-keyed cache and reads THAT copy,
 // so the bundle pin alone is ineffective once a cache exists. Pin every cached
 // copy too. Cache root is overridable for tests.
@@ -2062,8 +2220,7 @@ function ensureClaudeCodeMarketplace(marketplaceDir, pluginSource, force) {
 
 function runClaudeCodeInstall(args) {
   const pluginSource = resolveClaudeCodePluginSource();
-  const pinnedEnv = pinEditorMcpEnv(pluginSource);
-  const pinnedCache = pinClaudeCacheCopies();
+  const pinnedEnv = { pinned: false, reason: "plugin source is immutable" };
   const force = hasFlag(args, "--force");
   const skipEnable = hasFlag(args, "--skip-enable");
   const claudeBin = commandPath("claude");
@@ -2125,6 +2282,7 @@ function runClaudeCodeInstall(args) {
   }
 
   const ok = enable.skipped || enable.ok;
+  const pinnedCache = pinClaudeCacheCopies();
   const pluginDirFlagFull = `claude --plugin-dir ${pluginSource}`;
   console.log(
     JSON.stringify(
@@ -2149,75 +2307,115 @@ function runClaudeCodeInstall(args) {
   return enable.skipped || enable.ok ? 0 : 1;
 }
 
-function hermesInstallPresent(env = process.env) {
-  const hermesHome = resolveHermesHome(env);
-  return (
-    fs.existsSync(path.join(hermesHome, "plugins", "agent_wallet")) ||
-    fs.existsSync(path.join(hermesHome, ".env"))
-  );
-}
-
-function codexInstallPresent(env = process.env) {
-  return (
-    fs.existsSync(path.join(resolveCodexPluginInstallRoot(env), "agent-wallet")) ||
-    fs.existsSync(resolveCodexMarketplacePath(env))
-  );
+function runtimeReleasePath(value, env = process.env) {
+  if (!value) return false;
+  try {
+    const releasesRoot = path.join(resolveRuntimeBase(env), "releases");
+    const relative = path.relative(releasesRoot, path.resolve(expandHome(String(value))));
+    return Boolean(relative) && relative !== ".." && !relative.startsWith(`..${path.sep}`);
+  } catch {
+    return false;
+  }
 }
 
-function claudeCodeInstallPresent(env = process.env) {
-  const marketplaceDir = resolveClaudeCodeMarketplaceDir(env);
-  const cacheRoot = path.resolve(
-    expandHome(env.AGENT_WALLET_CLAUDE_CODE_CACHE_ROOT || "~/.claude/plugins/cache"),
-  );
-  return (
-    fs.existsSync(path.join(marketplaceDir, "plugins", "agent-wallet")) ||
-    fs.existsSync(path.join(cacheRoot, CLAUDE_CODE_MARKETPLACE_NAME, "agent-wallet"))
-  );
+function pathEntryExists(pathname) {
+  try {
+    fs.lstatSync(pathname);
+    return true;
+  } catch (error) {
+    if (error?.code === "ENOENT") return false;
+    throw error;
+  }
 }
 
-function captureInstallerRefresh(name, runFn, args) {
-  const originalLog = console.log;
-  const lines = [];
-  console.log = (...items) => {
-    lines.push(items.join(" "));
-  };
+function repairRuntimeSymlink(name, linkPath, desiredTarget, env = process.env) {
+  let rawTarget;
   try {
-    const code = runFn(args);
-    const output = lines.join("\n");
-    return {
-      name,
-      attempted: true,
-      ok: code === 0,
-      code,
-      payload: output ? extractTrailingJson(output) : null,
-      error: code === 0 ? "" : output.trim(),
-    };
+    const stat = fs.lstatSync(linkPath);
+    if (!stat.isSymbolicLink()) {
+      return { name, attempted: false, ok: true, repaired: false, reason: "not a symlink" };
+    }
+    rawTarget = fs.readlinkSync(linkPath);
   } catch (error) {
-    return {
-      name,
-      attempted: true,
-      ok: false,
-      code: 1,
-      payload: null,
-      error: error?.message || String(error),
-    };
-  } finally {
-    console.log = originalLog;
+    if (error?.code === "ENOENT") {
+      return { name, attempted: false, ok: true, repaired: false, reason: "not installed" };
+    }
+    return { name, attempted: true, ok: false, repaired: false, error: error.message };
+  }
+
+  const absoluteTarget = path.resolve(path.dirname(linkPath), rawTarget);
+  const logicalCurrent = currentRuntimePath(env);
+  if (absoluteTarget === path.resolve(desiredTarget) || absoluteTarget.startsWith(`${logicalCurrent}${path.sep}`)) {
+    return { name, attempted: true, ok: true, repaired: false, reason: "already current" };
+  }
+  if (!runtimeReleasePath(absoluteTarget, env)) {
+    return { name, attempted: false, ok: true, repaired: false, reason: "external target preserved" };
   }
+  if (!fs.existsSync(desiredTarget)) {
+    return { name, attempted: true, ok: false, repaired: false, error: `missing ${desiredTarget}` };
+  }
+  switchSymlink(linkPath, desiredTarget);
+  return { name, attempted: true, ok: true, repaired: true, target: desiredTarget };
 }
 
-function refreshInstalledEditorIntegrations(env = process.env) {
-  const results = [];
-  if (hermesInstallPresent(env)) {
-    results.push(captureInstallerRefresh("hermes", runHermesInstall, ["--yes", "--force", "--skip-enable"]));
+function repairHermesEnv(env = process.env) {
+  const envPath = path.join(resolveHermesHome(env), ".env");
+  const existing = readEnvFile(envPath);
+  const repaired = [];
+  const currentPackage = path.join(currentRuntimePath(env), "agent-wallet");
+  if (runtimeReleasePath(existing.AGENT_WALLET_PACKAGE_ROOT, env)) {
+    envFileSet(envPath, { AGENT_WALLET_PACKAGE_ROOT: currentPackage });
+    repaired.push("AGENT_WALLET_PACKAGE_ROOT");
+  }
+  if (runtimeReleasePath(existing.AGENT_WALLET_PYTHON, env)) {
+    const currentPython = resolveVenvPython(currentRuntimePath(env));
+    if (currentPython) {
+      envFileSet(envPath, { AGENT_WALLET_PYTHON: currentPython });
+    } else {
+      envFileUnset(envPath, ["AGENT_WALLET_PYTHON"]);
+    }
+    repaired.push("AGENT_WALLET_PYTHON");
   }
-  if (codexInstallPresent(env)) {
-    results.push(captureInstallerRefresh("codex", runCodexInstall, ["--yes", "--force", "--skip-enable"]));
+  return repaired;
+}
+
+function repairInstalledEditorIntegrations(env = process.env) {
+  const results = [];
+  const currentRoot = currentRuntimePath(env);
+  const hermesTarget = path.join(resolveHermesHome(env), "plugins", "agent_wallet");
+  if (pathEntryExists(hermesTarget) || fs.existsSync(path.join(resolveHermesHome(env), ".env"))) {
+    const result = repairRuntimeSymlink(
+      "hermes",
+      hermesTarget,
+      path.join(currentRoot, "hermes", "plugins", "agent_wallet"),
+      env,
+    );
+    result.env_repaired = repairHermesEnv(env);
+    results.push(result);
   }
-  if (claudeCodeInstallPresent(env)) {
+
+  const codexTarget = path.join(resolveCodexPluginInstallRoot(env), "agent-wallet");
+  if (pathEntryExists(codexTarget)) {
     results.push(
-      captureInstallerRefresh("claude-code", runClaudeCodeInstall, ["--yes", "--force", "--skip-enable"]),
+      repairRuntimeSymlink(
+        "codex",
+        codexTarget,
+        path.join(currentRoot, "codex", "plugins", "agent-wallet"),
+        env,
+      ),
+    );
+  }
+
+  const claudeTarget = path.join(resolveClaudeCodeMarketplaceDir(env), "plugins", "agent-wallet");
+  if (pathEntryExists(claudeTarget)) {
+    const result = repairRuntimeSymlink(
+      "claude-code",
+      claudeTarget,
+      path.join(currentRoot, "claude-code", "plugins", "agent-wallet"),
+      env,
     );
+    result.cache_pins = pinClaudeCacheCopies(env);
+    results.push(result);
   }
   return results;
 }

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

@@ -1,7 +1,7 @@
 {
   "name": "agent-wallet",
   "displayName": "Agent Wallet",
-  "version": "0.1.72",
+  "version": "0.1.74",
   "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/codex/plugins/agent-wallet/.codex-plugin/plugin.json

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

package/hermes/plugins/agent_wallet/plugin.yaml

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentlayer.tech/wallet",
-  "version": "0.1.72",
+  "version": "0.1.74",
   "description": "NPM installer for the OpenClaw Agent Wallet local runtime.",
   "type": "module",
   "repository": {
@@ -19,6 +19,7 @@
     "build:openclaw-plugins": "node scripts/manage_openclaw_plugin_packages.mjs build",
     "check:openclaw-plugins": "node scripts/manage_openclaw_plugin_packages.mjs check",
     "check:release-version": "node scripts/check_release_version.mjs",
+    "test:release-promotion": "node --test scripts/validate_npm_promotion.test.mjs",
     "version:sync": "node scripts/sync_version.mjs",
     "release:local": "node scripts/release_local.mjs",
     "test:npm-installer": "python3 agent-wallet/tests/smoke_npm_installer.py",

package/wdk-btc-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdk-btc-wallet",
-  "version": "0.1.72",
+  "version": "0.1.74",
   "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.72",
+  "version": "0.1.74",
   "private": true,
   "type": "module",
   "description": "Separate EVM wallet service built on Tether WDK.",
@@ -14,7 +14,8 @@
     "test:morpho-runtime": "node --test --test-concurrency=1 tests/smoke_morpho_runtime.mjs",
     "test:lido-runtime": "node --test --test-concurrency=1 tests/smoke_lido_runtime.mjs",
     "test:uniswap-runtime": "node --test --test-concurrency=1 tests/smoke_uniswap_runtime.mjs",
-    "test:unit": "node --test tests/unit_uniswap_helpers.mjs"
+    "test:unit": "node --test tests/unit_uniswap_helpers.mjs",
+    "test:identity": "node --test tests/unit_instance_identity.mjs"
   },
   "dependencies": {
     "@morpho-org/morpho-sdk": "^3.2.0",

package/wdk-evm-wallet/src/config.js

@@ -150,6 +150,27 @@ function ensureLocalAuthToken(tokenPath, configuredToken = "") {
   return generated;
 }
 
+function ensureInstanceId(instanceIdPath, configuredInstanceId = "") {
+  const direct = String(configuredInstanceId ?? "").trim();
+  if (direct) {
+    return direct;
+  }
+  fs.mkdirSync(path.dirname(instanceIdPath), { recursive: true, mode: 0o700 });
+  try {
+    const existing = fs.readFileSync(instanceIdPath, "utf8").trim();
+    if (existing) {
+      fs.chmodSync(instanceIdPath, 0o600);
+      return existing;
+    }
+  } catch {
+    // Generate a stable install identity below.
+  }
+  const generated = crypto.randomUUID();
+  fs.writeFileSync(instanceIdPath, generated + "\n", { encoding: "utf8", mode: 0o600 });
+  fs.chmodSync(instanceIdPath, 0o600);
+  return generated;
+}
+
 function normalizeNetworkKey(value) {
   const normalized = String(value ?? "").trim().toLowerCase();
   const aliases = {
@@ -201,6 +222,8 @@ export function loadConfig(env = process.env) {
   const authTokenPath =
     String(env.WDK_EVM_LOCAL_TOKEN_PATH ?? "").trim() ||
     path.join(openClawHome, "wdk-evm-wallet", "local-auth-token");
+  const instanceIdPath =
+    String(env.WDK_EVM_INSTANCE_ID_PATH ?? "").trim() || path.join(dataDir, "instance-id");
   const providerMode = parseProviderMode(env.WDK_EVM_RPC_PROVIDER_MODE, "gateway");
   const providerGatewayUrl =
     String(env.PROVIDER_GATEWAY_URL ?? "").trim() || DEFAULT_PROVIDER_GATEWAY_URL;
@@ -294,6 +317,7 @@ export function loadConfig(env = process.env) {
     network,
     openClawHome,
     dataDir,
+    instanceId: ensureInstanceId(instanceIdPath, env.WDK_EVM_INSTANCE_ID),
     authRequired: true,
     authTokenPath,
     authToken: ensureLocalAuthToken(authTokenPath, env.WDK_EVM_LOCAL_TOKEN),