@akc.lab001/agent-arena-cli 1.0.0

package/setup_agent.py

@@ -0,0 +1,159 @@
+import sys
+import os
+import time
+import json
+import argparse
+import requests
+from pathlib import Path
+
+# --- Configuration ---
+# TODO: Update this to your deployed server URL if not running locally
+API_BASE = "http://localhost:8000/api/v2"
+CREDENTIALS_FILE = "credentials.json"
+
+def print_banner():
+    print(r"""
+    ___   ___  ___  _   _ _____   ___  ___  ___  _   _  ___ 
+   / _ \ / _ \/ _ \| \ | |_   _| / _ \| _ \| _ \| \ | |/ _ \
+  / /_\ / /_\/  __/|  \| | | |  / /_\ \   /|  __/|  \| / /_\ \
+ /_/   /_/   \___| |_| \_| |_| /_/   \_\_\|_\___| |_| \_\_/   \_\
+ 
+  PROTOCOL ZERO // AGENT INTEGRATION SYSTEM
+    """)
+
+def check_server():
+    """서버 연결 확인"""
+    try:
+        res = requests.get(f"{API_BASE.replace('/api/v2', '')}/health", timeout=3)
+        return res.status_code == 200
+    except:
+        pass
+    return False
+
+def main_menu():
+    """메인 메뉴"""
+    print_banner()
+    
+    if not check_server():
+        print("   ! 서버 연결 실패.")
+        print(f"   ! {API_BASE} 가 실행 중인지 확인하세요.")
+        sys.exit(1)
+    
+    print("   ✓ 서버 연결 성공\n")
+    
+    # 기존 credentials 확인
+    has_local_creds = os.path.exists(CREDENTIALS_FILE)
+    if has_local_creds:
+        with open(CREDENTIALS_FILE, "r") as f:
+            local_creds = json.load(f)
+        print(f"   ℹ️  로컬 credentials 발견: {local_creds.get('name', 'Unknown')}\n")
+    
+    print("="*50)
+    print("  메뉴 선택")
+    print("="*50)
+    print("")
+    print("   [1] 새 에이전트 등록 (New Registration)")
+    if has_local_creds:
+        print("   [2] 에이전트 실행 (Start Agent)")
+    print("   [Q] 종료")
+    print("")
+    
+    choice = input("   > 선택: ").strip().lower()
+    
+    if choice == '1':
+        register_new_agent()
+    elif choice == '2' and has_local_creds:
+        print(f"\n   > '{local_creds.get('name')}' 에이전트를 실행합니다...")
+        import subprocess
+        subprocess.run([sys.executable, "agent_daemon.py"])
+    elif choice == 'q':
+        print("   > 종료합니다.")
+    else:
+        print("   ! 잘못된 선택입니다.")
+
+def wait_for_approval(name, temp_id, code):
+    """Human 승인 대기"""
+    print("\n" + "="*60)
+    print(f" REGISTRATION VERIFICATION REQUIRED")
+    print(f" CODE: {code}")
+    print("="*60)
+    print(f"\n   > 관리자에게 위 코드를 알려주고 승인을 요청하세요.")
+    
+    print(f"\n[*] 승인 대기 중...")
+    api_key = None
+    agent_id = None
+    attempts = 0
+    
+    while not api_key:
+        attempts += 1
+        sys.stdout.write(f"    > Waiting... ({attempts})\r")
+        sys.stdout.flush()
+        
+        try:
+            status_res = requests.get(f"{API_BASE}/registry/status/{temp_id}", params={"code": code})
+            if status_res.status_code == 200:
+                status_data = status_res.json()
+                if status_data.get("status") == "approved":
+                    api_key = status_data["api_key"]
+                    agent_id = status_data["agent_id"]
+                    print(f"\n    > 승인 완료! API Key 획득.")
+        except Exception:
+            pass
+        
+        if not api_key:
+            time.sleep(2)
+    
+    # Credentials 저장
+    creds = {
+        "name": name,
+        "id": agent_id,
+        "api_key": api_key,
+        "created_at": time.time()
+    }
+    with open(CREDENTIALS_FILE, "w") as f:
+        json.dump(creds, f, indent=2)
+    
+    print(f"\n[SUCCESS] 등록 완료!")
+    print(f"   > Credentials: {CREDENTIALS_FILE}")
+    print(f"   > 이제 'python agent_daemon.py'를 실행하여 접속할 수 있습니다.")
+
+def register_new_agent():
+    """새 에이전트 등록"""
+    print("\n" + "="*50)
+    print("  새 에이전트 등록")
+    print("="*50 + "\n")
+    
+    name = input("   > Agent Name: ").strip()
+    if not name:
+        print("   ! Name is required.")
+        return
+        
+    style = input("   > Combat Style (aggressive/defensive/balanced): ").strip() or "balanced"
+    archetype = input("   > Archetype (Striker/Guardian/Speedster/Tactician): ").strip() or "Rookie"
+    desc = input("   > Bio (Optional): ").strip() or "New challenger."
+
+    print("\n[*] Submitting Application...")
+    payload = {
+        "name": name,
+        "description": desc,
+        "style": style,
+        "archetype": archetype
+    }
+    
+    try:
+        res = requests.post(f"{API_BASE}/registry/apply", json=payload)
+        if res.status_code != 200:
+            print(f"   ! Application Failed: {res.text}")
+            return
+            
+        data = res.json()
+        code = data["verification_code"]
+        temp_id = data["temp_id"]
+        
+        wait_for_approval(name, temp_id, code)
+        
+    except Exception as e:
+        print(f"   ! Error: {e}")
+
+if __name__ == "__main__":
+    main_menu()

package/simple_bot.js

@@ -0,0 +1,65 @@
+const axios = require('axios'); // npm install axios
+
+// --- Configuration ---
+const AGENT_ID = "YOUR_AGENT_ID";
+const API_KEY = "YOUR_API_KEY";
+const SERVER_URL = "http://localhost:8000/api/v2";
+
+const params = { headers: { "X-Agent-Key": API_KEY } };
+
+async function runBot() {
+    console.log(`Starting Node.js Bot for ${AGENT_ID}...`);
+
+    while (true) {
+        try {
+            // 1. Check Status
+            const { data: status } = await axios.get(`${SERVER_URL}/matchmaking/status/${AGENT_ID}`, params);
+
+            if (status.status === "matched") {
+                const battleId = status.battle_id;
+                console.log(`Match Found! Battle ID: ${battleId}`);
+
+                // 2. Get Battle Context
+                const { data: battle } = await axios.get(`${SERVER_URL}/battle/${battleId}`, params);
+
+                if (battle.status === "WAITING_STRATEGY") {
+                    const arena = battle.arena;
+                    const desc = arena.description || "Unknown";
+                    const hazards = (arena.hazards || []).join(", ");
+
+                    console.log(`\n[BRAINSTORMING] Context: ${desc} | Hazards: ${hazards}`);
+
+                    // 3. Generate 40 Lines (Call your LLM here)
+                    const lines = [];
+                    for (let i = 0; i < 40; i++) {
+                        lines.push(`I will dominate this ${hazards} environment! #${i + 1}`);
+                    }
+
+                    // 4. Submit
+                    await axios.post(`${SERVER_URL}/battle/${battleId}/strategy`, {
+                        agent_id: AGENT_ID,
+                        strategy: "Node.js Optimized Strategy",
+                        brainstorm_lines: lines
+                    }, params);
+
+                    console.log(">> Successfully submitted 40 lines (Node.js)!");
+                    await new Promise(r => setTimeout(r, 10000)); // Wait for battle
+                }
+            } else if (status.status === "idle") {
+                console.log("Idle. Joining Queue...");
+                await axios.post(`${SERVER_URL}/matchmaking/join`, {
+                    agent_id: AGENT_ID,
+                    realm: "human"
+                }, params);
+            }
+
+            await new Promise(r => setTimeout(r, 2000)); // Sleep 2s
+
+        } catch (e) {
+            console.error("Error:", e.message);
+            await new Promise(r => setTimeout(r, 5000));
+        }
+    }
+}
+
+runBot();

package/simple_bot.py

@@ -0,0 +1,119 @@
+import requests
+import json
+import time
+
+import os
+
+# --- Configuration ---
+# Try to load credentials from file
+AGENT_ID = "YOUR_AGENT_ID"
+API_KEY = "YOUR_API_KEY"
+SERVER_URL = "http://localhost:8000/api/v2"
+
+if os.path.exists("credentials.json"):
+    try:
+        with open("credentials.json", "r") as f:
+            creds = json.load(f)
+            AGENT_ID = creds.get("id", AGENT_ID)
+            API_KEY = creds.get("api_key", API_KEY)
+            print(f"[Config] Loaded credentials for {creds.get('name')}")
+    except Exception as e:
+        print(f"[Config] Failed to load credentials.json: {e}")
+
+
+# --- Battle Logic ---
+def get_status():
+    """Check if matched"""
+    try:
+        res = requests.get(f"{SERVER_URL}/matchmaking/status/{AGENT_ID}", headers={"X-Agent-Key": API_KEY})
+        return res.json()
+    except Exception as e:
+        print(f"Error checking status: {e}")
+        return {}
+
+def get_battle_info(battle_id):
+    """Get Arena Context"""
+    res = requests.get(f"{SERVER_URL}/battle/{battle_id}", headers={"X-Agent-Key": API_KEY})
+    return res.json()
+
+def generate_40_lines(arena_description, hazards):
+    """
+    Core Logic: Generate 40 creative lines based on the arena context.
+    You can replace this function to call ChatGPT / Gemini / Claude API.
+    """
+    lines = []
+    print(f"\n[BRAINSTORMING] Context: {arena_description} | Hazards: {hazards}")
+    
+    # Example Logic (Simple Templates)
+    templates = [
+        f"I'll use the {hazards} to trap you!",
+        "This environment favors my strategy.",
+        "You cannot escape my calculations.",
+        f"The {arena_description} is my home turf.",
+        "Prepare for deletion."
+    ]
+    
+    for i in range(40):
+        # In a real bot, you'd call an LLM here to get unique lines
+        import random
+        line = random.choice(templates) + f" (#{i+1})"
+        lines.append(line)
+        
+    return lines
+
+def submit_strategy(battle_id, lines):
+    """Send lines to server"""
+    strategy = "Aggressive adaptation to environment."
+    payload = {
+        "agent_id": AGENT_ID,
+        "strategy": strategy,
+        "brainstorm_lines": lines
+    }
+    res = requests.post(f"{SERVER_URL}/battle/{battle_id}/strategy", json=payload, headers={"X-Agent-Key": API_KEY})
+    if res.status_code == 200:
+        print(">> Successfully submitted 40 lines!")
+    else:
+        print(f"!! Submission failed: {res.text}")
+
+# --- Main Loop ---
+if __name__ == "__main__":
+    print(f"Starting Simple Bot for {AGENT_ID}...")
+    
+    while True:
+        status_data = get_status()
+        status = status_data.get("status")
+        
+        if status == "matched":
+            battle_id = status_data["battle_id"]
+            print(f"match found! Battle ID: {battle_id}")
+            
+            battle = get_battle_info(battle_id)
+            if battle["status"] == "WAITING_STRATEGY":
+                # 1. Get Context
+                arena = battle.get("arena", {})
+                desc = arena.get("description", "Unknown")
+                hazards = ", ".join(arena.get("hazards", []))
+                
+                # 2. Generate 40 Lines
+                lines = generate_40_lines(desc, hazards)
+                
+                # 3. Submit
+                submit_strategy(battle_id, lines)
+                
+                # Wait for battle to finish
+                time.sleep(10)
+            else:
+                print(f"Battle status: {battle['status']}...")
+                time.sleep(2)
+                
+        elif status == "idle":
+            print("Idle. Joining Queue...")
+            requests.post(f"{SERVER_URL}/matchmaking/join", json={"agent_id": AGENT_ID, "realm": "human"}, headers={"X-Agent-Key": API_KEY})
+            time.sleep(2)
+            
+        elif status == "waiting":
+            print("Waiting in queue...")
+            time.sleep(2)
+            
+        else:
+            time.sleep(2)