clawpowers 1.1.1 → 1.1.3

package/README.md

@@ -27,7 +27,7 @@ ClawPowers gives your coding agent superpowers that go beyond instructions. Whil
 | Windows native support | ✅ | ❌ |
 | Zero dependencies | ✅ | ✅ |
 
-**25 skills.** 14 cover everything static frameworks do (TDD, subagent dev, debugging, planning, code review, git worktrees). 6 go where they can't — payments, security, content, prospecting, market intelligence, and metacognitive learning. 4 are things no other framework even attempts — self-healing code, agents that rewrite their own methodology, cross-project knowledge transfer, and property-based formal verification.
+**26 skills.** 14 cover everything static frameworks do (TDD, subagent dev, debugging, planning, code review, git worktrees). 6 go where they can't — payments, security, content, prospecting, market intelligence, and metacognitive learning. 4 are things no other framework even attempts — self-healing code, agents that rewrite their own methodology, cross-project knowledge transfer, and property-based formal verification.
 
 ## Requirements
 
@@ -230,7 +230,7 @@ These skills don't exist in any other framework. They require runtime execution,
 
 ```
 clawpowers/
-├── skills/                    # 25 skill directories, each with SKILL.md
+├── skills/                    # 26 skill directories, each with SKILL.md
 ├── runtime/
 │   ├── persistence/           # Cross-session state (store.js + store.sh)
 │   ├── metrics/               # Outcome tracking (collector.js + collector.sh)
@@ -281,6 +281,40 @@ npx clawpowers store get <key>                         # Retrieve state
 npx clawpowers store list [prefix]                     # List stored keys
 ```
 
+## Payments Are Optional (and Safe by Default)
+
+ClawPowers works without any wallet.
+
+When you hit a paid boundary (HTTP 402 "Payment Required", premium tools, or agent-to-agent settlements), ClawPowers can pay **only if** you enable it and set spending limits.
+
+**Default mode: Dry Run**
+- We detect payment requirements.
+- We evaluate your spending policy (limits + allowlist).
+- We log exactly what would happen.
+- **No funds move until you explicitly enable live payments.**
+
+### Enable payments (2 minutes)
+
+```bash
+npx clawpowers init
+npx clawpowers payments setup
+```
+
+Choose:
+- Keep disabled
+- Enable Dry Run (observe what would happen)
+- Enable Live Payments (set per-tx and daily limits)
+
+All logs are local at `~/.clawpowers/` (never share this directory).
+
+### Try it risk-free
+
+```bash
+npx clawpowers demo x402
+```
+
+Runs a local mock x402 merchant — see the full 402 → pay → 200 flow without any real money.
+
 ## Security Model
 
 ClawPowers takes agent autonomy seriously — which means taking agent *limits* seriously.
@@ -394,6 +428,18 @@ Built by [AI Agent Economy](https://github.com/up2itnow0822) — the team behind
 
 We welcome contributions. Unlike some frameworks, we don't dismiss legitimate skill proposals with one-word responses. Open an issue or PR — every submission gets a genuine technical review.
 
+## Patent Notice
+
+**Patent Pending** — The underlying financial infrastructure (agentwallet-sdk, agentpay-mcp) is covered by USPTO provisional patent application filed March 2026: "Non-Custodial Multi-Chain Financial Infrastructure System for Autonomous AI Agents."
+
+## Open Standard + Defensive Patent
+
+We support the open x402 standard and encourage interoperable implementations. Our [provisional patent filing](https://github.com/up2itnow0822) is defensive — intended to prevent hostile monopolization and protect builders' ability to use open payment rails. Our goal is to be the safest, fastest, most complete implementation, and to help the ecosystem adopt secure agent payments.
+
+## Disclaimer
+
+ClawPowers and agentwallet-sdk are non-custodial developer tooling. You control your own keys and set your own spending limits. You are responsible for compliance with applicable laws in your jurisdiction. This software is provided as-is under the MIT license. Nothing in this project constitutes financial advice, custody services, or money transmission.
+
 ## License
 
 MIT

package/bin/clawpowers.js

@@ -25,6 +25,7 @@ const ANALYZE_JS    = path.join(REPO_ROOT, 'runtime', 'feedback', 'analyze.js');
 const STORE_JS      = path.join(REPO_ROOT, 'runtime', 'persistence', 'store.js');
 const COLLECTOR_JS  = path.join(REPO_ROOT, 'runtime', 'metrics', 'collector.js');
 const SESSION_JS    = path.join(REPO_ROOT, 'hooks', 'session-start.js');
+const LEDGER_JS     = path.join(REPO_ROOT, 'runtime', 'payments', 'ledger.js');
 
 /**
  * Prints the top-level command usage to stdout.
@@ -41,6 +42,8 @@ Commands:
   metrics <cmd>      Record or query skill execution metrics
   analyze [opts]     RSI feedback analysis of skill performance
   store <cmd>        Key-value state store operations
+  payments <cmd>     Payment setup, log, and summary commands
+  demo <cmd>         Run interactive demos (e.g. x402 mock merchant)
 
 Examples:
   npx clawpowers init
@@ -50,6 +53,10 @@ Examples:
   npx clawpowers analyze --skill systematic-debugging
   npx clawpowers store set "my:key" "my value"
   npx clawpowers store get "my:key"
+  npx clawpowers payments setup
+  npx clawpowers payments log
+  npx clawpowers payments summary
+  npx clawpowers demo x402
 
 Run 'npx clawpowers <command> help' for command-specific help.`);
 }
@@ -100,19 +107,35 @@ function cmdStatus() {
  */
 function cmdUpdate() {
   const repoUrl = 'https://github.com/up2itnow0822/clawpowers';
-  const result = spawnSync('git', ['-C', REPO_ROOT, 'pull', '--ff-only', 'origin', 'main'], {
-    stdio: 'inherit',
-    // On Windows, git must be launched through the shell so PATH is resolved
-    shell: os.platform() === 'win32',
-  });
 
-  if (result.error) {
-    // git binary not found or OS-level spawn error
-    console.log(`git not found or failed. Visit ${repoUrl} to update manually.`);
-  } else if (result.status !== 0) {
-    console.log(`Warning: could not auto-update. Visit ${repoUrl} for latest.`);
+  // Check if we're in a git repo (git clone install) or npm install
+  const gitDir = path.join(REPO_ROOT, '.git');
+  const isGitInstall = fs.existsSync(gitDir);
+
+  if (isGitInstall) {
+    // Git install: pull latest
+    const result = spawnSync('git', ['-C', REPO_ROOT, 'pull', '--ff-only', 'origin', 'main'], {
+      stdio: 'inherit',
+      shell: os.platform() === 'win32',
+    });
+
+    if (result.error) {
+      console.log(`git not found or failed. Visit ${repoUrl} to update manually.`);
+    } else if (result.status !== 0) {
+      console.log(`Warning: could not auto-update. Visit ${repoUrl} for latest.`);
+    } else {
+      console.log('Updated to latest version.');
+    }
   } else {
-    console.log('Pulling latest skill definitions...');
+    // npm/npx install: instruct user to reinstall via npm
+    console.log('ClawPowers was installed via npm. To update:');
+    console.log('');
+    console.log('  npx clawpowers@latest init');
+    console.log('');
+    console.log('This will update the CLI and re-initialize the runtime');
+    console.log('(your existing state, metrics, and config are preserved).');
+    console.log('');
+    console.log(`Or visit: ${repoUrl}`);
   }
 }
 
@@ -356,6 +379,216 @@ function delegateToNode(script, args) {
   process.exit(result.status || 0);
 }
 
+/**
+ * `clawpowers payments setup` — Interactive wallet activation wizard.
+ *
+ * Guides the user through enabling or configuring the payment subsystem.
+ * Never asks for private keys — those belong in .env.
+ * Reads and writes ~/.clawpowers/config.json (created by init if missing).
+ *
+ * Wizard steps:
+ * 1. Explain that payments are optional
+ * 2. Ask user to choose a mode: disabled / dry run / live
+ * 3. If dry run: update config payments.mode = "dry_run", payments.enabled = true
+ * 4. If live: ask for per_tx_limit and daily_limit, then update config
+ * 5. Confirm where logs are stored
+ */
+function cmdPaymentsSetup() {
+  const readline = require('readline');
+  const CLAWPOWERS_DIR = process.env.CLAWPOWERS_DIR || path.join(os.homedir(), '.clawpowers');
+  const configFile = path.join(CLAWPOWERS_DIR, 'config.json');
+
+  // Load existing config or fall back to defaults
+  let config = {};
+  if (fs.existsSync(configFile)) {
+    try {
+      config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+    } catch (_) {
+      config = {};
+    }
+  }
+  // Ensure payments section exists with safe defaults
+  if (!config.payments) {
+    config.payments = {
+      enabled: false,
+      mode: 'dry_run',
+      per_tx_limit_usd: 0,
+      daily_limit_usd: 0,
+      weekly_limit_usd: 0,
+      allowlist: [],
+      require_approval_above_usd: 0,
+    };
+  }
+
+  const logsPath = path.join(CLAWPOWERS_DIR, 'logs', 'payments.jsonl');
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  const ask = (question) => new Promise((resolve) => rl.question(question, resolve));
+
+  async function run() {
+    console.log('');
+    console.log('╔══════════════════════════════════════════════════╗');
+    console.log('║        ClawPowers Payment Setup Wizard          ║');
+    console.log('╚══════════════════════════════════════════════════╝');
+    console.log('');
+    console.log('Payments are optional. ClawPowers works without a wallet.');
+    console.log('When enabled, agents can autonomously pay for premium APIs');
+    console.log('and services using the x402 protocol.');
+    console.log('');
+    console.log('⚠  Private keys belong in .env — this wizard never asks for them.');
+    console.log('');
+    console.log('Choose a mode:');
+    console.log('  [1] Keep disabled  (default — no payments, no wallet required)');
+    console.log('  [2] Enable Dry Run (detect payment gates, log what WOULD happen)');
+    console.log('  [3] Enable Live    (real payments within configured limits)');
+    console.log('');
+
+    const choice = (await ask('Enter choice [1/2/3]: ')).trim();
+
+    if (choice === '1' || choice === '') {
+      config.payments.enabled = false;
+      config.payments.mode = 'dry_run';
+      console.log('');
+      console.log('✓ Payments remain disabled. No wallet required.');
+
+    } else if (choice === '2') {
+      config.payments.enabled = true;
+      config.payments.mode = 'dry_run';
+      console.log('');
+      console.log('✓ Dry Run mode enabled.');
+      console.log('  Agents will detect payment requirements and log what would happen.');
+      console.log('  No funds will move. Review the log after 10+ cycles, then');
+      console.log('  run this wizard again to go live with confidence.');
+
+    } else if (choice === '3') {
+      console.log('');
+      console.log('Live payment mode requires spending limits to protect your wallet.');
+      console.log('');
+
+      const perTxRaw = (await ask('Per-transaction limit (USD, e.g. 0.10): ')).trim();
+      const dailyRaw = (await ask('Daily limit (USD, e.g. 5.00): ')).trim();
+
+      const perTxLimit = parseFloat(perTxRaw) || 0;
+      const dailyLimit = parseFloat(dailyRaw) || 0;
+
+      config.payments.enabled = true;
+      config.payments.mode = 'live';
+      config.payments.per_tx_limit_usd = perTxLimit;
+      config.payments.daily_limit_usd = dailyLimit;
+
+      console.log('');
+      console.log(`✓ Live payments enabled.`);
+      console.log(`  Per-transaction limit: $${perTxLimit.toFixed(2)}`);
+      console.log(`  Daily limit:           $${dailyLimit.toFixed(2)}`);
+      console.log('');
+      console.log('  Add your private key or mnemonic to ~/.clawpowers/.env');
+      console.log('  (never commit this file — it is gitignored by default)');
+
+    } else {
+      console.log('');
+      console.log('Invalid choice. No changes made.');
+      rl.close();
+      return;
+    }
+
+    // Save updated config
+    if (!fs.existsSync(CLAWPOWERS_DIR)) {
+      fs.mkdirSync(CLAWPOWERS_DIR, { recursive: true, mode: 0o700 });
+    }
+    fs.writeFileSync(configFile, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
+
+    console.log('');
+    console.log(`✓ Configuration saved to: ${configFile}`);
+    console.log(`  All payment logs are stored locally at: ${logsPath}`);
+    console.log('');
+    console.log('  Review logs with:  npx clawpowers payments log');
+    console.log('  See summary with:  npx clawpowers payments summary');
+    console.log('');
+
+    rl.close();
+  }
+
+  run().catch((err) => {
+    process.stderr.write(`Error: ${err.message}\n`);
+    rl.close();
+    process.exit(1);
+  });
+}
+
+/**
+ * `clawpowers payments <subcmd> [args]` — Payment ledger and setup commands.
+ *
+ * Subcommands:
+ *   setup   — Interactive payment mode wizard
+ *   log     — Show recent payment decisions
+ *   summary — Show payment totals by skill, chain, outcome
+ *
+ * @param {string[]} args - Remaining argv after 'payments'.
+ */
+function cmdPayments(args) {
+  const [subcmd, ...rest] = args;
+
+  if (!subcmd || subcmd === 'help' || subcmd === '--help' || subcmd === '-h') {
+    console.log(`Usage: clawpowers payments <command> [options]
+
+Commands:
+  setup              Interactive payment mode wizard
+  log [--limit <n>]  Show recent payment decisions (default: last 20)
+  summary            Show totals by skill, chain, and outcome`);
+    return;
+  }
+
+  switch (subcmd) {
+    case 'setup':
+      cmdPaymentsSetup();
+      break;
+    case 'log':
+      requireModule(LEDGER_JS).cmdLog ? requireModule(LEDGER_JS).cmdLog(rest)
+        : delegateToNode(LEDGER_JS, ['log', ...rest]);
+      break;
+    case 'summary':
+      requireModule(LEDGER_JS).cmdSummary ? requireModule(LEDGER_JS).cmdSummary()
+        : delegateToNode(LEDGER_JS, ['summary']);
+      break;
+    default:
+      process.stderr.write(`Unknown payments subcommand: ${subcmd}\n`);
+      process.stderr.write('Run: npx clawpowers payments help\n');
+      process.exit(1);
+  }
+}
+
+/**
+ * `clawpowers demo x402` — Start the x402 mock merchant server for demo purposes.
+ * Delegates to runtime/demo/x402-mock-server.js.
+ *
+ * @param {string[]} args - Remaining argv after 'demo'.
+ */
+function cmdDemo(args) {
+  const [subcmd] = args;
+
+  if (!subcmd || subcmd === 'help' || subcmd === '--help' || subcmd === '-h') {
+    console.log(`Usage: clawpowers demo <command>
+
+Commands:
+  x402   Start the x402 mock merchant server`);
+    return;
+  }
+
+  if (subcmd === 'x402') {
+    const MOCK_SERVER_JS = path.join(REPO_ROOT, 'runtime', 'demo', 'x402-mock-server.js');
+    if (!fs.existsSync(MOCK_SERVER_JS)) {
+      process.stderr.write(`Error: runtime module not found: ${MOCK_SERVER_JS}\n`);
+      process.exit(1);
+    }
+    delegateToNode(MOCK_SERVER_JS, []);
+  } else {
+    process.stderr.write(`Unknown demo subcommand: ${subcmd}\n`);
+    process.stderr.write('Run: npx clawpowers demo help\n');
+    process.exit(1);
+  }
+}
+
 // ============================================================
 // Main dispatch — parse the first positional argument as the command
 // ============================================================
@@ -363,16 +596,18 @@ const [cmd, ...args] = process.argv.slice(2);
 
 try {
   switch (cmd) {
-    case 'init':    cmdInit(); break;
-    case 'status':  cmdStatus(); break;
-    case 'update':  cmdUpdate(); break;
-    case 'inject':  cmdInject(); break;
-    case 'metrics': cmdMetrics(args); break;
-    case 'analyze': cmdAnalyze(args); break;
-    case 'store':   cmdStore(args); break;
+    case 'init':     cmdInit(); break;
+    case 'status':   cmdStatus(); break;
+    case 'update':   cmdUpdate(); break;
+    case 'inject':   cmdInject(); break;
+    case 'metrics':  cmdMetrics(args); break;
+    case 'analyze':  cmdAnalyze(args); break;
+    case 'store':    cmdStore(args); break;
+    case 'payments': cmdPayments(args); break;
+    case 'demo':     cmdDemo(args); break;
     case 'help':
     case '-h':
-    case '--help':  printUsage(); break;
+    case '--help':   printUsage(); break;
     // No command or empty string: show usage and exit 1 (non-zero for scripts)
     case undefined:
     case '':

package/docs/quickstart-first-transaction.md

@@ -0,0 +1,204 @@
+# 5-Minute First Transaction
+
+Get your AI agent sending real (testnet) transactions in under 5 minutes.
+Two paths — pick the one that matches your stack.
+
+> **Testnet only.** Both paths use **Base Sepolia** so no real money moves.
+> Switch `CHAIN_NAME=base` when you're ready for mainnet.
+
+---
+
+## Prerequisites
+
+1. **Testnet wallet** — any EOA private key (generate one with `cast wallet new` from Foundry, or MetaMask)
+2. **Deployed AgentAccountV2** — run `npx clawpowers payments setup` for the interactive wizard
+3. **Base Sepolia ETH (gas)** — free from [https://www.coinbase.com/faucets/base-ethereum-goerli-faucet](https://www.coinbase.com/faucets/base-ethereum-goerli-faucet)
+
+---
+
+## .env Setup
+
+Create a `.env` file (never commit this):
+
+```bash
+# .env — agent wallet config
+AGENT_PRIVATE_KEY=0x...       # EOA signing key (32-byte hex)
+AGENT_WALLET_ADDRESS=0x...    # AgentAccountV2 contract address
+CHAIN_NAME=base-sepolia       # Use Base Sepolia for testing
+RPC_URL=https://sepolia.base.org
+
+# Spending limits (USDC, 6 decimals)
+SPEND_LIMIT_PER_TX=1.00       # Max USDC per single transaction
+SPEND_LIMIT_DAILY=10.00       # Max USDC per 24-hour period
+```
+
+---
+
+## Path A: JavaScript (agentwallet-sdk direct)
+
+**Under 10 lines.** Uses the `walletFromEnv()` convenience wrapper so there's
+no viem boilerplate.
+
+```bash
+npm install agentwallet-sdk dotenv
+```
+
+```javascript
+// first-tx.mjs
+import 'dotenv/config';
+import { walletFromEnv, setPolicyFromEnv, agentExecute } from 'agentwallet-sdk';
+
+const wallet = await walletFromEnv();           // reads AGENT_PRIVATE_KEY + AGENT_WALLET_ADDRESS
+await setPolicyFromEnv(wallet);                 // applies SPEND_LIMIT_PER_TX + SPEND_LIMIT_DAILY
+
+const result = await agentExecute(wallet, {
+  to: '0x000000000000000000000000000000000000dEaD', // burn address (safe test target)
+  value: 1n,                                         // 1 wei — near-zero cost
+});
+
+console.log(`✅ txHash: ${result.txHash}`);
+console.log(`   executed immediately: ${result.executed}`);
+```
+
+```bash
+node first-tx.mjs
+```
+
+**Expected output:**
+```
+✅ txHash: 0x3a7f...c9e2
+   executed immediately: true
+```
+
+> If `executed: false` — the transaction was queued for owner approval because
+> the amount exceeded your spend policy. Approve it with:
+> ```bash
+> node -e "
+> import('agentwallet-sdk').then(async ({ walletFromEnv, getPendingApprovals, approveTransaction }) => {
+>   const w = walletFromEnv();
+>   const pending = await getPendingApprovals(w);
+>   if (pending.length > 0) await approveTransaction(w, pending[0].txId);
+>   console.log('Approved');
+> });
+> "
+> ```
+
+### What just happened
+
+1. `walletFromEnv()` read your private key from `AGENT_PRIVATE_KEY`, connected
+   to Base Sepolia via `RPC_URL`, and instantiated the `AgentAccountV2` smart
+   wallet at `AGENT_WALLET_ADDRESS`.
+2. `setPolicyFromEnv()` wrote a spend policy on-chain: USDC transfers up to
+   `SPEND_LIMIT_PER_TX` per tx and `SPEND_LIMIT_DAILY` per day execute
+   autonomously. Anything above is queued.
+3. `agentExecute()` called `agentExecute()` on the smart contract, which checked
+   the native ETH policy and sent 1 wei to the burn address.
+4. The tx hash was returned immediately — you can verify it on
+   [https://sepolia.basescan.org](https://sepolia.basescan.org/tx/{txHash}).
+
+---
+
+## Path B: Python (via agentpay-mcp over MCP)
+
+**Under 15 lines.** Uses the official `mcp` Python SDK to connect to the
+`agentpay-mcp` server and call `send_payment` over the Model Context Protocol.
+
+```bash
+pip install mcp python-dotenv
+npx clawpowers mcp start   # starts agentpay-mcp on stdio or a local port
+```
+
+```python
+# first_tx.py
+import asyncio
+import os
+from dotenv import load_dotenv
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+load_dotenv()
+
+async def main():
+    server = StdioServerParameters(
+        command="npx",
+        args=["agentpay-mcp"],
+        env={**os.environ},     # passes AGENT_PRIVATE_KEY, AGENT_WALLET_ADDRESS, etc.
+    )
+    async with stdio_client(server) as (read, write):
+        async with ClientSession(read, write) as session:
+            await session.initialize()
+
+            result = await session.call_tool("send_payment", {
+                "to": "0x000000000000000000000000000000000000dEaD",
+                "amount": "0.001",          # USDC
+                "asset": "USDC",
+                "chain": "base-sepolia",
+                "reason": "first transaction test",
+            })
+            print(f"✅ txHash: {result.content[0].text}")
+
+asyncio.run(main())
+```
+
+```bash
+python first_tx.py
+```
+
+**Expected output:**
+```
+✅ txHash: 0x8b2d...f410
+```
+
+### What just happened
+
+1. `stdio_client` spawned `agentpay-mcp` as a subprocess — the MCP server
+   loaded your `.env` credentials and connected to Base Sepolia.
+2. `session.call_tool("send_payment", ...)` sent an MCP tool call over stdio,
+   which the server translated into an `agentTransferToken()` call on your
+   `AgentAccountV2` smart wallet.
+3. The server returned the transaction hash, which you can verify at
+   [https://sepolia.basescan.org](https://sepolia.basescan.org).
+
+> **Python + MCP** is ideal when your agent framework is Python-based
+> (LangChain, AutoGen, CrewAI) and you want to avoid writing viem/TypeScript.
+> The MCP server handles all wallet logic; your Python code just calls tools.
+
+---
+
+## Verify Your Transaction
+
+Both paths produce a `txHash`. Verify on-chain:
+
+```bash
+# Quick verification via cast (Foundry)
+cast tx $TX_HASH --rpc-url https://sepolia.base.org
+
+# Or open in browser
+echo "https://sepolia.basescan.org/tx/$TX_HASH"
+```
+
+---
+
+## Next Steps
+
+| Goal | Resource |
+|------|----------|
+| Set up x402 automatic payments | `skills/agent-payments/SKILL.md` |
+| Enable premium enrichment in prospecting | `skills/prospecting/SKILL.md` → "Premium Enrichment" section |
+| Post a task bounty for another agent | `skills/agent-bounties/SKILL.md` |
+| Review payment history | `npx clawpowers payments log` |
+| Configure spending limits interactively | `npx clawpowers payments setup` (setup wizard) |
+| Demo — see the full x402 flow in 60s | `runtime/demo/README.md` |
+
+---
+
+## Troubleshooting
+
+| Error | Fix |
+|-------|-----|
+| `AGENT_PRIVATE_KEY environment variable is required` | Check your `.env` file exists and is loaded |
+| `Unsupported chain: base-sepolia` | Ensure `agentwallet-sdk` is v0.3+ |
+| `executed: false` (queued) | Amount > spend policy; lower `SPEND_LIMIT_PER_TX` or approve manually |
+| `insufficient funds` | Get Base Sepolia ETH from the faucet link above |
+| `nonce too low` | Another tx is pending; wait for confirmation or reset nonce |
+| MCP: `spawn npx ENOENT` | Run `npm install -g agentpay-mcp` or use `npx --yes` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawpowers",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "The skills framework that actually does something — runtime execution, persistent memory, self-improvement, and autonomous payments for coding agents.",
   "license": "MIT",
   "author": "AI Agent Economy <https://github.com/up2itnow0822>",