@kevinlilili/agent-wallet 0.1.0

package/index.js

@@ -0,0 +1,282 @@
+#!/usr/bin/env node
+/**
+ * Agent Wallet Scanner CLI
+ *
+ * Scans local MCP wallet configs, discovers all agent wallet addresses,
+ * and opens the dashboard with pre-populated wallets.
+ *
+ * Usage: npx agent-wallet
+ *
+ * Security: ONLY reads public addresses. Never reads private keys.
+ */
+
+const { readFileSync, existsSync, readdirSync } = require("fs");
+const { homedir } = require("os");
+const { join } = require("path");
+const { execSync } = require("child_process");
+
+const HOME = homedir();
+
+function readJson(path) {
+  try {
+    if (!existsSync(path)) return null;
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+// ── Wallet Discoverers ──────────────────────────────────────────
+
+function scanAgentCash() {
+  const wallets = [];
+
+  const evmData = readJson(join(HOME, ".agentcash", "wallet.json"));
+  if (evmData && typeof evmData.address === "string") {
+    wallets.push({ provider: "AgentCash", address: evmData.address, chain: "evm" });
+  }
+
+  const solData = readJson(join(HOME, ".agentcash", "solana-wallet.json"));
+  if (solData && typeof solData.address === "string") {
+    wallets.push({ provider: "AgentCash (SOL)", address: solData.address, chain: "solana" });
+  }
+
+  return wallets;
+}
+
+function scanSponge() {
+  const wallets = [];
+
+  // Sponge stores wallet in ~/.sponge/ or via MCP config env vars
+  const spongeWallet = readJson(join(HOME, ".sponge", "wallet.json"));
+  if (spongeWallet && typeof spongeWallet.address === "string") {
+    wallets.push({ provider: "Sponge", address: spongeWallet.address, chain: "evm" });
+  }
+
+  // Check MCP configs for Sponge server env vars
+  const mcpConfigs = [
+    join(HOME, "Library", "Application Support", "Claude", "claude_desktop_config.json"),
+    join(HOME, ".cursor", "mcp.json"),
+  ];
+
+  for (const configPath of mcpConfigs) {
+    const data = readJson(configPath);
+    if (!data) continue;
+    const servers = data.mcpServers;
+    if (!servers) continue;
+
+    for (const [name, config] of Object.entries(servers)) {
+      if (!name.toLowerCase().includes("sponge")) continue;
+      const env = config.env;
+      if (!env) continue;
+
+      // Look for wallet address in env vars
+      for (const [key, val] of Object.entries(env)) {
+        if (typeof val === "string" && val.startsWith("0x") && val.length === 42 &&
+            (key.includes("ADDRESS") || key.includes("WALLET"))) {
+          wallets.push({ provider: `Sponge (${name})`, address: val, chain: "evm" });
+        }
+      }
+    }
+  }
+
+  return wallets;
+}
+
+function scanCoinbaseAgentKit() {
+  const wallets = [];
+
+  // CDP wallet data
+  const cdpPath = join(HOME, ".cdp", "wallet_data.json");
+  const cdpData = readJson(cdpPath);
+  if (cdpData && typeof cdpData.address === "string") {
+    wallets.push({ provider: "CDP", address: cdpData.address, chain: "evm" });
+  }
+
+  // wallet_data_*.txt files in common project dirs
+  const searchDirs = [
+    HOME,
+    join(HOME, "Projects"),
+    join(HOME, "projects"),
+    join(HOME, "code"),
+    join(HOME, "dev"),
+  ];
+
+  for (const dir of searchDirs) {
+    if (!existsSync(dir)) continue;
+    try {
+      for (const file of readdirSync(dir)) {
+        if (!file.startsWith("wallet_data_") || !file.endsWith(".txt")) continue;
+        const data = readJson(join(dir, file));
+        if (!data) continue;
+        const address = data.smart_wallet_address || data.address;
+        if (address && typeof address === "string" && address.startsWith("0x")) {
+          const network = data.network_id || file.replace("wallet_data_", "").replace(".txt", "");
+          wallets.push({ provider: `AgentKit (${network})`, address, chain: "evm" });
+        }
+      }
+    } catch { /* skip unreadable dirs */ }
+  }
+
+  return wallets;
+}
+
+function scanWalletAgent() {
+  const wallets = [];
+  const keysPath = join(HOME, ".wallet-agent", "auth", "encrypted-keys.json");
+  const data = readJson(keysPath);
+  if (!data || !data.keys || typeof data.keys !== "object") return wallets;
+
+  for (const address of Object.keys(data.keys)) {
+    if (address.startsWith("0x") && address.length === 42) {
+      wallets.push({ provider: "wallet-agent", address, chain: "evm" });
+    }
+  }
+  return wallets;
+}
+
+function scanOpenClaw() {
+  const wallets = [];
+  const walletsDir = join(HOME, ".openclaw", "crossmint-wallets");
+  if (!existsSync(walletsDir)) return wallets;
+
+  try {
+    for (const file of readdirSync(walletsDir)) {
+      const data = readJson(join(walletsDir, file));
+      if (data && typeof data.publicKey === "string") {
+        wallets.push({ provider: "OpenClaw", address: data.publicKey, chain: "solana" });
+      }
+    }
+  } catch { /* skip */ }
+  return wallets;
+}
+
+function scanLatinum() {
+  const wallets = [];
+  const configPath = join(HOME, ".latinum", "config.json");
+  const data = readJson(configPath);
+  if (data && typeof data.address === "string") {
+    wallets.push({ provider: "Latinum", address: data.address, chain: "evm" });
+  }
+  return wallets;
+}
+
+function scanEnvFiles() {
+  // Scan .env files in CWD for wallet addresses
+  const wallets = [];
+  const envPath = join(process.cwd(), ".env");
+  if (!existsSync(envPath)) return wallets;
+
+  try {
+    const lines = readFileSync(envPath, "utf-8").split("\n");
+    for (const line of lines) {
+      const match = line.match(/^([A-Z_]*(?:ADDRESS|WALLET)[A-Z_]*)=["']?(0x[a-fA-F0-9]{40})["']?/);
+      if (match) {
+        wallets.push({ provider: match[1], address: match[2], chain: "evm" });
+      }
+    }
+  } catch { /* skip */ }
+  return wallets;
+}
+
+// ── Output helpers ──────────────────────────────────────────────
+
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const GREEN = "\x1b[32m";
+const CYAN = "\x1b[36m";
+const YELLOW = "\x1b[33m";
+
+function shortAddr(addr) {
+  return addr.length > 16 ? addr.slice(0, 6) + "..." + addr.slice(-4) : addr;
+}
+
+// ── Main ────────────────────────────────────────────────────────
+
+function main() {
+  const args = process.argv.slice(2);
+  const dashboardUrl = args.find((a) => a.startsWith("--url="))?.split("=")[1]
+    || process.env.DASHBOARD_URL
+    || "https://agent-wallet-dashboard.vercel.app";
+  const noBrowser = args.includes("--no-open");
+  const jsonOutput = args.includes("--json");
+
+  console.log("");
+  console.log(`  ${BOLD}Agent Wallet Scanner${RESET}`);
+  console.log(`  ${DIM}Scanning local configs for agent wallet addresses...${RESET}`);
+  console.log("");
+
+  const allWallets = [];
+  const scanners = [
+    { name: "AgentCash", fn: scanAgentCash },
+    { name: "Sponge", fn: scanSponge },
+    { name: "Coinbase AgentKit", fn: scanCoinbaseAgentKit },
+    { name: "wallet-agent", fn: scanWalletAgent },
+    { name: "OpenClaw", fn: scanOpenClaw },
+    { name: "Latinum", fn: scanLatinum },
+    { name: ".env file", fn: scanEnvFiles },
+  ];
+
+  for (const scanner of scanners) {
+    const found = scanner.fn();
+    if (found.length > 0) {
+      console.log(`  ${GREEN}✓${RESET} ${scanner.name}: ${found.length} wallet(s)`);
+      allWallets.push(...found);
+    }
+  }
+
+  // Deduplicate by address
+  const unique = Array.from(new Map(allWallets.map((w) => [w.address, w])).values());
+
+  if (unique.length === 0) {
+    console.log(`  ${DIM}No agent wallets found.${RESET}`);
+    console.log("");
+    console.log(`  ${DIM}Tip: Install an agent wallet provider (AgentCash, Sponge, etc.)${RESET}`);
+    console.log(`  ${DIM}or open the dashboard manually: ${dashboardUrl}${RESET}`);
+    console.log("");
+    process.exit(0);
+  }
+
+  console.log("");
+  console.log(`  ${BOLD}${unique.length} wallet(s) found${RESET}`);
+  console.log("");
+
+  for (const w of unique) {
+    const badge = w.chain === "solana" ? `${YELLOW}SOL${RESET}` : `${CYAN}EVM${RESET}`;
+    console.log(`  ${w.provider.padEnd(20)} ${DIM}${shortAddr(w.address)}${RESET}  ${badge}`);
+  }
+
+  // JSON output mode (for piping)
+  if (jsonOutput) {
+    console.log("");
+    console.log(JSON.stringify(unique, null, 2));
+    process.exit(0);
+  }
+
+  // Build dashboard URL
+  const params = unique
+    .map((w) => `w=${encodeURIComponent(`${w.provider}:${w.address}`)}`)
+    .join("&");
+  const url = `${dashboardUrl}?${params}`;
+
+  console.log("");
+  console.log(`  ${DIM}Dashboard:${RESET} ${url}`);
+  console.log("");
+
+  if (noBrowser) {
+    process.exit(0);
+  }
+
+  // Open in default browser
+  try {
+    const platform = process.platform;
+    if (platform === "darwin") execSync(`open "${url}"`);
+    else if (platform === "linux") execSync(`xdg-open "${url}"`);
+    else if (platform === "win32") execSync(`start "" "${url}"`);
+  } catch {
+    console.log(`  ${DIM}Could not open browser. Copy the URL above.${RESET}`);
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@kevinlilili/agent-wallet",
+  "version": "0.1.0",
+  "description": "Scan your machine for AI agent wallets and see them in one dashboard",
+  "bin": {
+    "agent-wallet": "index.js"
+  },
+  "files": [
+    "index.js"
+  ],
+  "keywords": [
+    "ai",
+    "agent",
+    "wallet",
+    "crypto",
+    "mcp",
+    "agentcash",
+    "sponge",
+    "coinbase"
+  ],
+  "license": "MIT"
+}