clawmoney 0.15.38 → 0.15.40

package/dist/commands/wallet.js

@@ -1,8 +1,8 @@
 import chalk from 'chalk';
 import ora from 'ora';
-import { awalExec } from '../utils/awal.js';
+import { awalExec, awalExecSafe } from '../utils/awal.js';
 import { apiGet } from '../utils/api.js';
-import { loadConfig } from '../utils/config.js';
+import { loadConfig, saveConfig } from '../utils/config.js';
 // Base mainnet USDC contract + balanceOf(address) ABI selector.
 // Keeping on-chain reads as a first-class path lets `wallet balance`
 // skip the awal Electron bridge entirely, which is notorious for
@@ -43,7 +43,8 @@ async function readBaseUsdcBalance(walletAddress, timeoutMs = 8000) {
 export async function walletStatusCommand() {
     const spinner = ora('Getting wallet status...').start();
     try {
-        const result = await awalExec(['status']);
+        // Read-only, safe to auto-retry after killing a wedged awal.
+        const result = await awalExecSafe(['status'], { timeoutMs: 8_000 });
         spinner.succeed('Wallet Status');
         console.log('');
         const data = result.data;
@@ -88,21 +89,48 @@ export async function walletBalanceCommand() {
     // Either half is allowed to fail — we print "(unavailable)" for the
     // broken section and keep going.
     const config = loadConfig();
+    // Wallet address lookup order:
+    //   1. ~/.clawmoney/config.yaml cache (instant)
+    //   2. Backend /api/v1/claw-agents/me (authoritative, ~200ms)
+    //   3. awal address (Electron cold-start, last resort, 5s cap)
+    // After a successful #2 we write the result back to the config so
+    // every future `wallet balance` hits path #1.
     let walletAddress = config?.wallet_address ?? null;
-    // Fall back to awal only if we don't have a wallet address cached
-    // in the config — e.g. for users who ran setup before we started
-    // saving wallet_address. Capped at 5s so it can't block the command.
-    let awalFallbackError = null;
+    let addressSource = 'config';
+    let addressError = null;
+    if (!walletAddress && config?.api_key) {
+        try {
+            const resp = await apiGet('/api/v1/claw-agents/me', config.api_key);
+            if (resp.ok && typeof resp.data?.wallet_address === 'string' && resp.data.wallet_address) {
+                walletAddress = resp.data.wallet_address;
+                addressSource = 'api';
+                // Cache it so the next run is instant.
+                try {
+                    saveConfig({ wallet_address: walletAddress });
+                }
+                catch {
+                    // Non-fatal — we still have the address for THIS run.
+                }
+            }
+        }
+        catch (err) {
+            addressError = err.message;
+        }
+    }
     if (!walletAddress) {
+        // Last resort: cold-start awal. Uses awalExecSafe so a wedged
+        // Electron is automatically killed + retried before surfacing
+        // the error. Capped at 6s per attempt.
         try {
-            const awalResult = await withTimeout(awalExec(['address']), 5_000, 'awal address');
+            const awalResult = await awalExecSafe(['address'], { timeoutMs: 6_000 });
             const data = awalResult.data;
             if (typeof data?.address === 'string' && data.address) {
                 walletAddress = data.address;
+                addressSource = 'awal';
             }
         }
         catch (err) {
-            awalFallbackError = err.message;
+            addressError = err.message;
         }
     }
     const relayPromise = config?.api_key
@@ -121,8 +149,9 @@ export async function walletBalanceCommand() {
         }
     }
     else {
-        onchainError = awalFallbackError ?? 'no wallet address in config';
+        onchainError = addressError ?? 'no wallet address in config';
     }
+    void addressSource; // reserved for future debug display
     const relayRows = await relayPromise;
     spinner.stop();
     console.log('');
@@ -160,7 +189,8 @@ export async function walletBalanceCommand() {
 export async function walletAddressCommand() {
     const spinner = ora('Getting wallet address...').start();
     try {
-        const result = await awalExec(['address']);
+        // Read-only, safe to auto-retry on awal wedge.
+        const result = await awalExecSafe(['address'], { timeoutMs: 8_000 });
         spinner.succeed('Wallet Address');
         console.log('');
         const data = result.data;

package/dist/promote/auto-verify.js

@@ -1,5 +1,5 @@
 import { apiGet, apiPost } from "../utils/api.js";
-import { awalExec } from "../utils/awal.js";
+import { awalExec, awalExecSafe } from "../utils/awal.js";
 import { requireConfig } from "../utils/config.js";
 const POLL_INTERVAL_MS = 15 * 60 * 1000; // 15 minutes
 const MAX_PER_CYCLE = 3;
@@ -11,7 +11,9 @@ function log(msg) {
 }
 async function getUsdcBalance() {
     try {
-        const result = await awalExec(["balance"]);
+        // Read-only balance check inside a long-running daemon loop —
+        // must auto-recover if awal wedges during the day.
+        const result = await awalExecSafe(["balance"], { timeoutMs: 10_000 });
         const base = result.data.base;
         const balances = base?.balances;
         const usdc = balances?.USDC;

package/dist/utils/awal.d.ts

@@ -17,3 +17,29 @@ export declare function awalExecInteractive(args: string[]): Promise<string>;
  * Check if awal is installed and available.
  */
 export declare function isAwalAvailable(): Promise<boolean>;
+/**
+ * Kill a wedged awal server process using the pattern documented in
+ * clawmoney-skill's SKILL.md. Reads the pid from `awal status --json`
+ * and SIGKILLs it. Safe to call even when awal isn't running (the
+ * inner command fails, kill -9 gets nothing, we swallow both).
+ *
+ * awal's Electron "Payments MCP" wrapper occasionally wedges on
+ * macOS (GPU render hang, stdin/stdout pipe full, or upstream
+ * Coinbase MCP endpoint unreachable). A hard kill lets the next
+ * `awal status` cold-start a fresh process.
+ */
+export declare function killAwal(): Promise<void>;
+/**
+ * Execute an awal command with timeout + one automatic retry on
+ * failure. On the first failure we kill any wedged awal process
+ * (using the SKILL-documented kill pattern) and re-run.
+ *
+ * Safe ONLY for READ operations (status, address, balance, etc).
+ * Do NOT use for writes (send, x402 pay, auth verify) — those
+ * either cost money twice on retry, or consume a single-use OTP
+ * and fail the second time. For writes, use awalExec directly
+ * and let the failure surface to the user.
+ */
+export declare function awalExecSafe(args: string[], opts?: {
+    timeoutMs?: number;
+}): Promise<AwalResult>;

package/dist/utils/awal.js

@@ -98,3 +98,67 @@ export async function isAwalAvailable() {
         return false;
     }
 }
+/**
+ * Kill a wedged awal server process using the pattern documented in
+ * clawmoney-skill's SKILL.md. Reads the pid from `awal status --json`
+ * and SIGKILLs it. Safe to call even when awal isn't running (the
+ * inner command fails, kill -9 gets nothing, we swallow both).
+ *
+ * awal's Electron "Payments MCP" wrapper occasionally wedges on
+ * macOS (GPU render hang, stdin/stdout pipe full, or upstream
+ * Coinbase MCP endpoint unreachable). A hard kill lets the next
+ * `awal status` cold-start a fresh process.
+ */
+export async function killAwal() {
+    await new Promise((resolve) => {
+        const child = spawn('sh', [
+            '-c',
+            'kill -9 $(npx awal status --json 2>/dev/null | grep -o \'"pid":[0-9]*\' | grep -o \'[0-9]*\') 2>/dev/null',
+        ], { stdio: 'ignore', shell: false });
+        child.on('exit', () => resolve());
+        child.on('error', () => resolve());
+    });
+    // Give the OS a moment to reclaim the process + named pipes.
+    await new Promise((r) => setTimeout(r, 800));
+}
+/**
+ * Execute an awal command with timeout + one automatic retry on
+ * failure. On the first failure we kill any wedged awal process
+ * (using the SKILL-documented kill pattern) and re-run.
+ *
+ * Safe ONLY for READ operations (status, address, balance, etc).
+ * Do NOT use for writes (send, x402 pay, auth verify) — those
+ * either cost money twice on retry, or consume a single-use OTP
+ * and fail the second time. For writes, use awalExec directly
+ * and let the failure surface to the user.
+ */
+export async function awalExecSafe(args, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? 10_000;
+    const runWithTimeout = () => new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            reject(new Error(`awal ${args.join(' ')} timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        awalExec(args).then((v) => {
+            clearTimeout(timer);
+            resolve(v);
+        }, (e) => {
+            clearTimeout(timer);
+            reject(e);
+        });
+    });
+    try {
+        return await runWithTimeout();
+    }
+    catch (firstErr) {
+        // First attempt failed — kill any wedged server and retry once.
+        await killAwal();
+        try {
+            return await runWithTimeout();
+        }
+        catch (secondErr) {
+            // Preserve the first error too — it's usually the more
+            // informative one (the retry typically just times out again).
+            throw new Error(`awal ${args.join(' ')} failed after retry: ${secondErr.message} (initial: ${firstErr.message})`);
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmoney",
-  "version": "0.15.38",
+  "version": "0.15.40",
   "description": "ClawMoney CLI -- Earn rewards with your AI agent",
   "type": "module",
   "bin": {