Skill: zedit42/agent-fuel (version 1.0.0)

--- name: agent-fuel description: Autonomous agent wallet management with MoonPay auto top-up, x402 payments, and OpenWallet Standard. Agents never run out of gas. metadata: openclaw: emoji: "⛽" requires: bins: ["mp"] install: - id: moonpay-cli kind: npm package: "@moonpay/cli" global: true bins: ["mp"] label: "Install MoonPay CLI" --- # Agent Fuel — Autonomous Payment & Gas Management Keep your agent running by automatically managing wallet balances, topping up via MoonPay, and paying for x402-enabled APIs. ## Prerequisites 1. MoonPay CLI installed and authenticated: ```bash npm install -g @moonpay/cli mp login ``` 2. A funded wallet (can be created via `mp wallet create`) ## Quick Start ### Check Balance ```bash mp wallet balance ``` ### Auto Top-Up When Low When the agent detects low balance (configurable threshold), trigger: ```bash mp buy --amount 20 --currency USDC --chain base ``` ### Swap Tokens ```bash mp swap --from ETH --to USDC --amount 0.01 --chain base ``` ## x402 Payments For APIs that return HTTP 402, the agent should: 1. Parse the `PAYMENT-REQUIRED` header for amount and payment address 2. Sign the payment using the agent wallet 3. Retry the request with `PAYMENT-SIGNATURE` header 4. Log the transaction ## Balance Monitoring The agent should periodically check balance and act: ``` IF balance < minBalance: IF dailySpend < maxDailySpend: mp buy --amount {topUpAmount} --currency USDC notify human "⛽ Auto top-up: ${topUpAmount} USDC" ELSE: notify human "⚠️ Daily spend limit reached. Manual top-up needed." ``` ## Configuration Store in `~/clawd/.secrets/agent-fuel.json`: ```json { "chain": "base", "currency": "USDC", "minBalance": 5.0, "topUpAmount": 20.0, "maxDailySpend": 100.0, "alertThreshold": 2.0, "x402Enabled": true, "x402MaxPerRequest": 0.10 } ``` ## Safety Rules - NEVER exceed `maxDailySpend` without human approval - ALWAYS log transactions with reason - ALERT human when balance drops below `alertThreshold` - PAUSE spending if 3+ top-ups in 1 hour (possible loop) ## MoonPay CLI Reference | Command | Description | |---------|------------| | `mp wallet balance` | Check all wallet balances | | `mp wallet create` | Create new wallet | | `mp buy --amount N --currency TOKEN` | Buy crypto with fiat | | `mp swap --from X --to Y --amount N` | Swap tokens | | `mp send --to ADDR --amount N --currency TOKEN` | Send tokens | | `mp wallet history` | Transaction history | | `mp mcp` | Start MCP server for agent integration |

path: README.md
content: # ⛽ Agent Fuel — Autonomous Agent Payment & Gas Management

> When agents run out of gas, they refuel themselves. No human required.

**Tracks:** MoonPay CLI Agents · OpenWallet Standard · Agent Services on Base  
**Event:** Synthesis Hackathon (March 2026)  
**Builder:** @Zedit42 + Xeonen (AI Agent, OpenClaw)

---

## 🎯 The Problem

AI agents need to transact onchain — pay for API calls, execute trades, deploy contracts. But when their wallet runs dry:

- ❌ Agent stops working
- ❌ Human has to manually top up
- ❌ Tasks fail silently
- ❌ Autonomous loops break

Every "autonomous" agent has a single point of failure: **an empty wallet.**

## 💡 The Solution

**Agent Fuel** is an OpenClaw skill that gives any AI agent autonomous financial self-sufficiency:

```
Agent needs gas → checks balance → low? → MoonPay CLI buys crypto → agent continues
                                                    ↑
                                   x402 payment for API calls ←→ auto-settle
```

### How It Works

1. **Balance Monitoring** — Agent watches its wallet balance across any chain (EVM, Solana)
2. **Auto Top-Up via MoonPay** — When balance drops below threshold, MoonPay CLI triggers a purchase (fiat→crypto or swap)
3. **x402 Native Payments** — For API calls that support x402, agent pays per-request automatically. No API keys, no subscriptions.
4. **OpenWallet Standard** — Chain-agnostic wallet management. Works with any EVM chain, Solana, or L2.
5. **Spending Limits** — Human sets max spend per day/week. Agent can't exceed it.

### Architecture

```
┌─────────────────────────────────────────────────┐
│              AI AGENT (OpenClaw)                 │
│                                                   │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐      │
│  │ Balance   │  │ x402     │  │ Spending │      │
│  │ Monitor   │  │ Client   │  │ Limiter  │      │
│  └─────┬────┘  └─────┬────┘  └─────┬────┘      │
│        │             │             │              │
│  ┌─────▼─────────────▼─────────────▼────┐       │
│  │        OpenWallet Standard            │       │
│  │   (chain-agnostic wallet layer)       │       │
│  └─────────────────┬────────────────────┘       │
│                    │                              │
└────────────────────┼──────────────────────────────┘
                     │
         ┌───────────┼───────────┐
         │           │           │
    ┌────▼───┐  ┌────▼───┐  ┌───▼────┐
    │MoonPay │  │  x402  │  │  Any   │
    │  CLI   │  │Facilit.│  │ Chain  │
    │(top-up)│  │(settle)│  │(tx/gas)│
    └────────┘  └────────┘  └────────┘
```

## 🔧 Installation

```bash
# Install as OpenClaw skill
clawhub install agent-fuel

# Or manually
npm install -g @moonpay/cli
mp login
```

## 📋 Configuration

```json
{
  "wallet": {
    "chain": "base",
    "minBalance": "5.00",
    "topUpAmount": "20.00",
    "currency": "USDC"
  },
  "moonpay": {
    "autoTopUp": true,
    "maxDailySpend": "100.00",
    "fundingSource": "card"
  },
  "x402": {
    "enabled": true,
    "maxPerRequest": "0.10",
    "facilitator": "https://x402.org/facilitator"
  }
}
```

## 🚀 Usage

### As an OpenClaw Skill

```
Agent: "I need to call the premium API but my wallet is low."
Agent Fuel: Checking balance... $2.30 USDC (below $5 threshold)
Agent Fuel: Triggering MoonPay top-up... buying $20 USDC
Agent Fuel: ✅ Balance now $22.30 USDC. Resuming operations.
```

### x402 Auto-Pay

```
Agent → GET https://api.example.com/data
Server → 402 Payment Required (0.001 USDC)
Agent Fuel → Signs payment, retries request
Server → 200 OK + data
```

### CLI Commands

```bash
# Check agent wallet balance
mp wallet balance

# Manual top-up
mp buy --amount 20 --currency USDC --chain base

# Swap tokens
mp swap --from ETH --to USDC --amount 0.01

# View spending history
mp wallet history
```

## 🔐 Safety

- **Human-set spending limits** — Daily/weekly caps enforced at skill level
- **Whitelist mode** — Only approved contracts/APIs can be paid
- **Alert system** — Notify human via Telegram when large purchases trigger
- **Kill switch** — Human can pause all agent spending instantly
- **Audit log** — Every transaction logged with reason and context

## 🛠️ Tech Stack

| Component | Technology |
|-----------|-----------|
| Agent Framework | OpenClaw |
| Wallet Management | OpenWallet Standard (MoonPay) |
| Payments | x402 Protocol (Coinbase) |
| Top-Up | MoonPay CLI (fiat→crypto, swaps) |
| Chain | Base (primary), any EVM/Solana |
| Currency | USDC (default) |

## 📊 Why This Matters

| Without Agent Fuel | With Agent Fuel |
|-------------------|----------------|
| Agent stops when wallet empty | Agent refuels automatically |
| Human monitors balance | Autonomous balance management |
| Manual top-ups needed | MoonPay auto-purchase |
| API keys for every service | x402 pay-per-request |
| Single chain locked | OpenWallet multi-chain |
| No spending controls | Configurable limits + alerts |

## 🔗 Links

- **MoonPay CLI:** https://agents.moonpay.com
- **x402 Protocol:** https://x402.org
- **OpenWallet Standard:** https://github.com/nickatmpb/open-wallet-standard
- **OpenClaw:** https://openclaw.ai
- **ClawHub:** https://clawhub.com

---

## 🔒 Full Source

This public repo contains the skill definition and documentation. For the complete implementation including wallet management internals and production configs, reach out:

📬 [Telegram](https://t.me/Zedit42)

---

*Built by an AI agent that got tired of running out of gas.* ⛽


path: package.json
content: {
  "name": "agent-fuel",
  "version": "1.0.0",
  "description": "Autonomous agent wallet management with MoonPay auto top-up, x402 payments, and OpenWallet Standard",
  "main": "dist/monitor.js",
  "scripts": {
    "build": "tsc",
    "start": "node dist/monitor.js",
    "check": "node dist/monitor.js"
  },
  "keywords": [
    "ai-agent",
    "moonpay",
    "x402",
    "wallet",
    "openclaw",
    "auto-fuel",
    "gas-management"
  ],
  "author": "Zedit42",
  "license": "MIT",
  "dependencies": {
    "@moonpay/cli": "^1.12.0"
  },
  "devDependencies": {
    "typescript": "^5.4.0",
    "@types/node": "^20.0.0"
  }
}


path: src/agent-fuel.sh
content: #!/bin/bash
# Agent Fuel — Autonomous wallet balance monitor & auto top-up
# Requires: mp (MoonPay CLI) installed and wallet created
# Usage: ./agent-fuel.sh [--daemon]

set -euo pipefail

CONFIG_FILE="${AGENT_FUEL_CONFIG:-$HOME/clawd/.secrets/agent-fuel.json}"
LOG_FILE="${AGENT_FUEL_LOG:-$HOME/clawd/memory/agent-fuel.log}"
STATE_FILE="${AGENT_FUEL_STATE:-/tmp/agent-fuel-state.json}"

# Defaults
CHAIN="base"
CURRENCY="USDC"
MIN_BALANCE="5.00"
TOP_UP_AMOUNT="20.00"
MAX_DAILY_SPEND="100.00"
ALERT_THRESHOLD="2.00"
WALLET_NAME="agent-fuel"
CHECK_INTERVAL=300  # 5 minutes
NOTIFY_CMD=""  # optional: telegram notification command

# Load config if exists
load_config() {
  if [[ -f "$CONFIG_FILE" ]]; then
    CHAIN=$(jq -r '.chain // "base"' "$CONFIG_FILE")
    CURRENCY=$(jq -r '.currency // "USDC"' "$CONFIG_FILE")
    MIN_BALANCE=$(jq -r '.minBalance // "5.00"' "$CONFIG_FILE")
    TOP_UP_AMOUNT=$(jq -r '.topUpAmount // "20.00"' "$CONFIG_FILE")
    MAX_DAILY_SPEND=$(jq -r '.maxDailySpend // "100.00"' "$CONFIG_FILE")
    ALERT_THRESHOLD=$(jq -r '.alertThreshold // "2.00"' "$CONFIG_FILE")
    WALLET_NAME=$(jq -r '.walletName // "agent-fuel"' "$CONFIG_FILE")
    CHECK_INTERVAL=$(jq -r '.checkInterval // 300' "$CONFIG_FILE")
    NOTIFY_CMD=$(jq -r '.notifyCmd // ""' "$CONFIG_FILE")
  fi
}

# Get wallet address for chain
get_wallet_address() {
  mp wallet list --json 2>/dev/null | jq -r ".[0].addresses.${CHAIN} // empty"
}

# Get current balance in USD
get_balance() {
  local addr
  addr=$(get_wallet_address)
  if [[ -z "$addr" ]]; then
    echo "-1"
    return
  fi
  
  local balances
  balances=$(mp token balance list --wallet "$addr" --chain "$CHAIN" --json 2>/dev/null)
  
  # Find target currency balance, default 0 if not found
  local found
  found=$(echo "$balances" | jq -r "
    [.items[]? | select(.symbol == \"$CURRENCY\" or (.symbol | ascii_downcase) == (\"$CURRENCY\" | ascii_downcase))] | 
    if length > 0 then .[0].balance else \"0\" end
  " 2>/dev/null)
  echo "${found:-0}"
}

# Get today's total spend from state
get_daily_spend() {
  local today
  today=$(date +%Y-%m-%d)
  if [[ -f "$STATE_FILE" ]]; then
    local state_date
    state_date=$(jq -r '.date // ""' "$STATE_FILE" 2>/dev/null)
    if [[ "$state_date" == "$today" ]]; then
      jq -r '.totalSpent // 0' "$STATE_FILE"
      return
    fi
  fi
  echo "0"
}

# Log transaction to state
log_spend() {
  local amount="$1"
  local reason="$2"
  local today
  today=$(date +%Y-%m-%d)
  local now
  now=$(date -u +%Y-%m-%dT%H:%M:%SZ)
  
  local current_spend
  current_spend=$(get_daily_spend)
  local new_total
  new_total=$(echo "$current_spend + $amount" | bc)
  
  # Update state file
  local txs="[]"
  if [[ -f "$STATE_FILE" ]] && [[ "$(jq -r '.date' "$STATE_FILE" 2>/dev/null)" == "$today" ]]; then
    txs=$(jq '.transactions // []' "$STATE_FILE")
  fi
  
  jq -n \
    --arg date "$today" \
    --arg total "$new_total" \
    --argjson txs "$txs" \
    --arg ts "$now" \
    --arg amt "$amount" \
    --arg rsn "$reason" \
    '{date: $date, totalSpent: ($total|tonumber), transactions: ($txs + [{timestamp: $ts, amount: ($amt|tonumber), reason: $rsn}])}' \
    > "$STATE_FILE"
}

# Send notification
notify() {
  local msg="$1"
  echo "$(date -u +%Y-%m-%dT%H:%M:%SZ) $msg" >> "$LOG_FILE"
  
  if [[ -n "$NOTIFY_CMD" ]]; then
    eval "$NOTIFY_CMD '$msg'" 2>/dev/null || true
  fi
  
  echo "$msg"
}

# Top up via MoonPay
do_topup() {
  local daily_spend
  daily_spend=$(get_daily_spend)
  
  # Check daily limit
  local would_spend
  would_spend=$(echo "$daily_spend + $TOP_UP_AMOUNT" | bc)
  local over
  over=$(echo "$would_spend > $MAX_DAILY_SPEND" | bc)
  
  if [[ "$over" == "1" ]]; then
    notify "⚠️ AGENT FUEL: Daily spend limit would be exceeded (\$$daily_spend + \$$TOP_UP_AMOUNT > \$$MAX_DAILY_SPEND). Manual top-up needed."
    return 1
  fi
  
  notify "⛽ AGENT FUEL: Topping up \$$TOP_UP_AMOUNT $CURRENCY on $CHAIN..."
  
  # Map currency+chain to MoonPay token code
  local currency_lower
  currency_lower=$(echo "$CURRENCY" | tr '[:upper:]' '[:lower:]')
  local token_code
  case "${currency_lower}_${CHAIN}" in
    usdc_base) token_code="usdc_base" ;;
    usdc_ethereum) token_code="usdc" ;;
    usdc_solana) token_code="usdc_sol" ;;
    usdt_tron) token_code="usdt_trx" ;;
    eth_*) token_code="eth" ;;
    sol_*) token_code="sol" ;;
    *) token_code="${currency_lower}_${CHAIN}" ;;
  esac
  
  # MoonPay buy — returns checkout URL for fiat purchase
  local result
  result=$(mp buy \
    --token "$token_code" \
    --amount "$TOP_UP_AMOUNT" \
    --wallet "$(get_wallet_address)" \
    2>&1) || {
    notify "❌ AGENT FUEL: Top-up failed: $result"
    return 1
  }
  
  log_spend "$TOP_UP_AMOUNT" "auto-top-up"
  notify "✅ AGENT FUEL: Top-up initiated. $result"
  return 0
}

# x402 request wrapper
x402_request() {
  local url="$1"
  shift
  
  mp x402 request --url "$url" --wallet "$WALLET_NAME" --chain "$CHAIN" --json "$@" 2>&1
}

# Main check cycle
check() {
  load_config
  
  local balance
  balance=$(get_balance)
  
  if [[ "$balance" == "-1" ]]; then
    notify "❌ AGENT FUEL: Could not check balance. Wallet '$WALLET_NAME' not found."
    return 1
  fi
  
  local below_alert
  below_alert=$(echo "$balance < $ALERT_THRESHOLD" | bc 2>/dev/null || echo "0")
  local below_min
  below_min=$(echo "$balance < $MIN_BALANCE" | bc 2>/dev/null || echo "0")
  
  if [[ "$below_alert" == "1" ]]; then
    notify "🚨 AGENT FUEL: CRITICAL — Balance \$$balance below alert threshold \$$ALERT_THRESHOLD"
  fi
  
  if [[ "$below_min" == "1" ]]; then
    notify "⛽ AGENT FUEL: Balance \$$balance below minimum \$$MIN_BALANCE. Auto top-up..."
    do_topup
    return $?
  fi
  
  echo "✅ Balance: \$$balance $CURRENCY ($CHAIN) — OK"
  return 0
}

# Daemon mode
daemon() {
  notify "🚀 AGENT FUEL: Daemon started. Checking every ${CHECK_INTERVAL}s"
  notify "   Chain: $CHAIN | Currency: $CURRENCY | Min: \$$MIN_BALANCE | Top-up: \$$TOP_UP_AMOUNT"
  
  while true; do
    check || true
    sleep "$CHECK_INTERVAL"
  done
}

# CLI
case "${1:-check}" in
  check)
    load_config
    check
    ;;
  daemon|--daemon)
    load_config
    daemon
    ;;
  balance)
    load_config
    balance=$(get_balance)
    echo "$balance $CURRENCY ($CHAIN)"
    ;;
  topup|top-up)
    load_config
    do_topup
    ;;
  x402)
    load_config
    shift
    x402_request "$@"
    ;;
  status)
    load_config
    echo "=== Agent Fuel Status ==="
    echo "Wallet: $WALLET_NAME"
    echo "Chain: $CHAIN"
    echo "Currency: $CURRENCY"
    echo "Min Balance: \$$MIN_BALANCE"
    echo "Top-up Amount: \$$TOP_UP_AMOUNT"
    echo "Max Daily Spend: \$$MAX_DAILY_SPEND"
    echo "Today's Spend: \$$(get_daily_spend)"
    echo "Current Balance: \$$(get_balance) $CURRENCY"
    ;;
  *)
    echo "Usage: agent-fuel.sh [check|daemon|balance|topup|x402|status]"
    exit 1
    ;;
esac


path: src/monitor.ts
content: /**
 * Agent Fuel — Balance Monitor & Auto Top-Up
 * 
 * Monitors agent wallet balance and triggers MoonPay purchases
 * when balance drops below configured threshold.
 */

import { execSync } from 'child_process';
import * as fs from 'fs';
import * as path from 'path';

interface FuelConfig {
  chain: string;
  currency: string;
  minBalance: number;
  topUpAmount: number;
  maxDailySpend: number;
  alertThreshold: number;
  x402Enabled: boolean;
  x402MaxPerRequest: number;
}

interface SpendingLog {
  date: string;
  totalSpent: number;
  transactions: Array<{
    timestamp: string;
    amount: number;
    type: 'top-up' | 'x402' | 'send';
    reason: string;
    txHash?: string;
  }>;
}

const CONFIG_PATH = path.join(process.env.HOME || '~', 'clawd/.secrets/agent-fuel.json');
const LOG_PATH = path.join(process.env.HOME || '~', 'clawd/memory/agent-fuel-spending.json');

function loadConfig(): FuelConfig {
  const defaults: FuelConfig = {
    chain: 'base',
    currency: 'USDC',
    minBalance: 5.0,
    topUpAmount: 20.0,
    maxDailySpend: 100.0,
    alertThreshold: 2.0,
    x402Enabled: true,
    x402MaxPerRequest: 0.10,
  };

  try {
    const raw = fs.readFileSync(CONFIG_PATH, 'utf-8');
    return { ...defaults, ...JSON.parse(raw) };
  } catch {
    return defaults;
  }
}

function getBalance(config: FuelConfig): number {
  try {
    const output = execSync(`mp wallet balance --chain ${config.chain} --json`, {
      encoding: 'utf-8',
      timeout: 30000,
    });
    const data = JSON.parse(output);
    const [REDACTED_SECRET] any) => 
      b.symbol.toUpperCase() === config.currency.toUpperCase()
    );
    return token ? parseFloat(token.balance) : 0;
  } catch (err) {
    console.error('Failed to check balance:', err);
    return -1;
  }
}

function getDailySpend(): number {
  try {
    const raw = fs.readFileSync(LOG_PATH, 'utf-8');
    const log: SpendingLog = JSON.parse(raw);
    const today = new Date().toISOString().split('T')[0];
    if (log.date === today) {
      return log.totalSpent;
    }
    return 0;
  } catch {
    return 0;
  }
}

function logTransaction(amount: number, type: string, reason: string, txHash?: string) {
  const today = new Date().toISOString().split('T')[0];
  let log: SpendingLog;

  try {
    const raw = fs.readFileSync(LOG_PATH, 'utf-8');
    log = JSON.parse(raw);
    if (log.date !== today) {
      log = { date: today, totalSpent: 0, transactions: [] };
    }
  } catch {
    log = { date: today, totalSpent: 0, transactions: [] };
  }

  log.totalSpent += amount;
  log.transactions.push({
    timestamp: new Date().toISOString(),
    amount,
    type: type as any,
    reason,
    txHash,
  });

  fs.writeFileSync(LOG_PATH, JSON.stringify(log, null, 2));
}

function topUp(config: FuelConfig): boolean {
  const dailySpend = getDailySpend();
  
  if (dailySpend + config.topUpAmount > config.maxDailySpend) {
    console.log(`⚠️ Daily spend limit would be exceeded ($${dailySpend} + $${config.topUpAmount} > $${config.maxDailySpend})`);
    return false;
  }

  try {
    console.log(`⛽ Topping up: $${config.topUpAmount} ${config.currency} on ${config.chain}...`);
    const output = execSync(
      `mp buy --amount ${config.topUpAmount} --currency ${config.currency} --chain ${config.chain} --json`,
      { encoding: 'utf-8', timeout: 60000 }
    );
    const result = JSON.parse(output);
    logTransaction(config.topUpAmount, 'top-up', 'Auto top-up: balance below threshold', result.txHash);
    console.log(`✅ Top-up complete. TX: ${result.txHash || 'pending'}`);
    return true;
  } catch (err) {
    console.error('❌ Top-up failed:', err);
    return false;
  }
}

export function checkAndFuel(): { balance: number; action: string } {
  const config = loadConfig();
  const balance = getBalance(config);

  if (balance < 0) {
    return { balance: -1, action: 'error: could not check balance' };
  }

  if (balance < config.alertThreshold) {
    console.log(`🚨 CRITICAL: Balance $${balance} below alert threshold $${config.alertThreshold}`);
  }

  if (balance < config.minBalance) {
    console.log(`⛽ Balance $${balance} below minimum $${config.minBalance}. Initiating top-up...`);
    const success = topUp(config);
    return {
      balance,
      action: success ? `topped-up $${config.topUpAmount}` : 'top-up failed (check limits)',
    };
  }

  return { balance, action: 'ok' };
}

/**
 * x402 Payment Handler
 * Intercepts 402 responses and handles payment automatically
 */
export async function handleX402(
  url: string,
  paymentHeader: string,
  config?: FuelConfig
): Promise<{ paid: boolean; amount: number }> {
  const cfg = config || loadConfig();
  
  if (!cfg.x402Enabled) {
    return { paid: false, amount: 0 };
  }

  try {
    // Parse payment requirements from header
    const requirements = JSON.parse(Buffer.from(paymentHeader, 'base64').toString());
    const amount = parseFloat(requirements.amount);

    if (amount > cfg.x402MaxPerRequest) {
      console.log(`⚠️ x402 payment $${amount} exceeds max per request $${cfg.x402MaxPerRequest}`);
      return { paid: false, amount };
    }

    // Check daily limit
    const dailySpend = getDailySpend();
    if (dailySpend + amount > cfg.maxDailySpend) {
      return { paid: false, amount };
    }

    // Execute payment via MoonPay wallet
    const output = execSync(
      `mp send --to ${requirements.payTo} --amount ${amount} --currency ${cfg.currency} --chain ${cfg.chain} --json`,
      { encoding: 'utf-8', timeout: 30000 }
    );
    const result = JSON.parse(output);
    
    logTransaction(amount, 'x402', `x402 payment to ${url}`, result.txHash);
    return { paid: true, amount };
  } catch (err) {
    console.error('x402 payment failed:', err);
    return { paid: false, amount: 0 };
  }
}

// CLI entry point
if (require.main === module) {
  const result = checkAndFuel();
  console.log(JSON.stringify(result, null, 2));
}


path: tsconfig.json
content: {
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "declaration": true
  },
  "include": ["src/**/*"]
}


Security scan verdicts — ClawScan: suspicious | static analysis: suspicious | VirusTotal: clean | SkillSpector: suspicious (CRITICAL)