clawmoney 0.15.39 → 0.15.41

package/dist/commands/wallet.js

@@ -1,6 +1,6 @@
 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, saveConfig } from '../utils/config.js';
 // Base mainnet USDC contract + balanceOf(address) ABI selector.
@@ -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;
@@ -117,10 +118,11 @@ export async function walletBalanceCommand() {
         }
     }
     if (!walletAddress) {
-        // Last resort: cold-start awal. Capped at 5s so a wedged wallet
-        // daemon can't block the command forever.
+        // 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;
@@ -166,14 +168,19 @@ export async function walletBalanceCommand() {
         console.log(`    ${chalk.yellow('unavailable')} ${chalk.dim('(' + (onchainError ?? 'unknown') + ')')}`);
     }
     console.log('');
-    console.log(chalk.bold('  Relay earnings'));
+    console.log(chalk.bold('  Pending payout (Relay)'));
     if (relayRows && relayRows.length > 0) {
+        // "Earned lifetime" is vanity — the only thing that matters for
+        // the wallet view is: how much is already in the on-chain wallet
+        // (shown above as USDC), and how much is still owed to the user
+        // (pending = earned - withdrawn). Those two numbers together
+        // tell the full story; showing "earned" separately would double-
+        // count the wallet USDC that came from relay payouts.
         const earned = relayRows.reduce((s, p) => s + (p.total_earned_usd ?? 0), 0);
         const withdrawn = relayRows.reduce((s, p) => s + (p.total_withdrawn_usd ?? 0), 0);
         const pending = Math.max(0, earned - withdrawn);
         const requests = relayRows.reduce((s, p) => s + (p.total_requests ?? 0), 0);
-        console.log(`    ${chalk.dim('Earned:').padEnd(22)} ${chalk.green('$' + earned.toFixed(2))}`);
-        console.log(`    ${chalk.dim('Pending payout:').padEnd(22)} ${chalk.green('$' + pending.toFixed(2))}`);
+        console.log(`    ${chalk.dim('Amount:').padEnd(22)} ${chalk.green('$' + pending.toFixed(2))}`);
         console.log(chalk.dim(`    (${relayRows.length} provider${relayRows.length === 1 ? "" : "s"} · ${requests} request${requests === 1 ? "" : "s"} served)`));
     }
     else if (relayRows && relayRows.length === 0) {
@@ -187,7 +194,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.39",
+  "version": "0.15.41",
   "description": "ClawMoney CLI -- Earn rewards with your AI agent",
   "type": "module",
   "bin": {