LSL → Python Server → 我（小蘋果/Apple AI）→ 回覆 → NPC 說話

Jeff 在 OSgrid 說話 → LSL HTTP → Python Server → Ollama → Group → Jeff 看到

Jeff 在 OSgrid 說話 → LSL HTTP → Python Server → 直接問我（小蘋果）→ NPC 回應

4/0AdeuBXXXXXXX...（很長的亂碼）

https://accounts.google.com/o/oauth2/auth?response_type=code&client_id=345293604428-l9jo09uffa2ctldfj0buul93aaougvld.apps.googleusercontent.com&scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fgmail.send&state=DL41zX34Zuc4Vz20OB1D7VG36FaGYx&code_challenge=JHDWdGPjgK6IAlMmGTFNeN9qCwJU7dC6zS9bSsF0yhg&code_challenge_method=S256&access_type=offline&prompt=consent&redirect_uri=http%3A%2F%2Flocalhost

urn:ietf:wg:oauth:2.0:oob

~/.gmail-venv/bin/python3 -c "
from flask import Flask, request
app = Flask(__name__)

@app.route('/')
def index():
    code = request.args.get('code', '')
    print(f'\\n=== Authorization Code ===\n{code}\n===========================')
    return 'Success! Code received. You can close this window.'

app.run(host='0.0.0.0', port=8080)
"

http://你的伺服器IP:8080

RCPT TO:<cs01@cspiston.com.tw,cs07@cspiston.com.tw,terry5401@gmail.com>

gog auth credentials ~/.config/client_secret_345293604428-m7uetpiqf5lj2os3rg4fho0dg860h5hc.apps.googleusercontent.com.json
gog auth add cs01@cspiston.com.tw --services gmail

TEXT: 你好！這是回覆內容
ACTION: WAVE

OSgrid → Python Server → Telegram Group → 我(Apple)回覆
                   ↑                              ↓
                   └──────── 讀取回覆 ←────────────┘

def send_tg_message(chat_id, text):
    chat_id = "7020731576"  # <- 這是 Jeff 的私訊，不是群組！
    requests.post(...)

def ai_chat():
    result = ask_ollama(user_input, npc_name)  # 直接問 Ollama
    return jsonify({...})  # 直接回傳，根本不碰 osgrid_message_queue

OSgrid → Python → Telegram → 我回覆 → Python 讀取 → 回傳 OSgrid

OSgrid ↔ Python Server ↔ Telegram Group ↔ 我（Apple）
                         ↓
              冒牌 Ollama（跳舞打扫用）

#!/usr/bin/env python3
"""
OSgrid AI NPC Server - Apple (我) 作為大腦
流程：OSgrid → Python → Telegram Group → Apple 回覆 → OSgrid
"""
import os
import re
import time
import threading
import requests
from flask import Flask, request, jsonify
from datetime import datetime

app = Flask(__name__)

# ========== 設定區 ==========
TG_BOT_TOKEN = os.getenv("TG_BOT_TOKEN", "8617880782:AAEk8-vYA2uOR-YlNn5hKu0nWm1mO0wpNK0")
TG_API_URL = f"https://api.telegram.org/bot{TG_BOT_TOKEN}/"
GROUP_CHAT_ID = int(os.getenv("TG_GROUP_ID", "-1002207534009"))

# 等待 Apple 回覆的超時時間（秒）
REPLY_TIMEOUT = 90

print(f"[啟動] OSgrid AI NPC Server (Apple Bridge)")
print(f"[設定] TG Bot Token: {TG_BOT_TOKEN[:20]}...")
print(f"[設定] Group Chat ID: {GROUP_CHAT_ID}")

# ========== 狀態 ==========
class State:
    def __init__(self):
        self.last_update_id = 0

state = State()

# ========== 工具函式 ==========
def send_tg_message(chat_id, text):
    """發送訊息到 Telegram"""
    payload = {"chat_id": chat_id, "text": text}
    try:
        resp = requests.post(f"{TG_API_URL}sendMessage", json=payload, timeout=10)
        result = resp.json()
        if result.get("ok"):
            return result.get("result", {}).get("message_id")
    except Exception as e:
        print(f"[TG 發送失敗] {e}")
    return None

def get_tg_updates(offset=0, timeout=5):
    """取得 Telegram 更新"""
    try:
        params = {"offset": offset, "timeout": timeout}
        resp = requests.get(f"{TG_API_URL}getUpdates", params=params, timeout=timeout + 5)
        return resp.json().get("result", [])
    except Exception as e:
        print(f"[TG getUpdates 失敗] {e}")
        return []

def find_apple_replies_in_group():
    """掃描群組訊息，找出 Apple 的回覆（包含 TEXT: 或 ACTION:）"""
    updates = get_tg_updates(offset=state.last_update_id)
    apple_messages = []
    
    for update in updates:
        update_id = update["update_id"]
        state.last_update_id = max(state.last_update_id, update_id)
        
        message = update.get("message") or update.get("edited_message")
        if not message or "text" not in message:
            continue
        
        msg_text = message["text"]
        chat_id = message.get("chat", {}).get("id")
        
        # 只看群組訊息
        if chat_id != GROUP_CHAT_ID:
            continue
        
        # 找出包含 TEXT: 或 ACTION: 的訊息（Apple 的回覆格式）
        if "TEXT:" in msg_text.upper() or "ACTION:" in msg_text.upper():
            apple_messages.append({
                "update_id": update_id,
                "text": msg_text,
                "message_id": message.get("message_id"),
                "date": message.get("date")
            })
            print(f"[發現 Apple 回覆] {msg_text[:80]}...")
    
    return apple_messages

def parse_apple_response(text):
    """解析 Apple 的回覆格式"""
    result = {"text": "", "action": None}
    
    # 解析 TEXT:
    text_match = re.search(r'TEXT:\s*(.+?)(?:\n|$)', text, re.IGNORECASE | re.DOTALL)
    if text_match:
        result["text"] = text_match.group(1).strip()
    
    # 解析 ACTION:
    action_match = re.search(r'ACTION:\s*(\w+)', text, re.IGNORECASE)
    if action_match:
        result["action"] = action_match.group(1).strip().lower()
    
    return result

# ========== Telegram Polling（背景執行） ==========
def telegram_polling():
    """背景執行：持續更新 last_update_id"""
    print("[TG Polling] 啟動背景監聽...")
    while True:
        try:
            updates = get_tg_updates(offset=state.last_update_id + 1, timeout=5)
            for update in updates:
                state.last_update_id = max(state.last_update_id, update["update_id"])
        except Exception as e:
            print(f"[TG Polling 錯誤] {e}")
        time.sleep(1)

# ========== Flask 路由 ==========
@app.route("/ai", methods=["POST"])
def osgrid_ai():
    """
    OSgrid LSL 呼叫點
    流程：接收 OSgrid 訊息 → 發送到 TG 群組 → 等待 Apple 回覆 → 回傳
    """
    data = request.json or {}
    os_message = data.get("message", "")
    npc_name = data.get("npc_name", "OSgrid 玩家")
    
    if not os_message:

#!/usr/bin/env python3
import os, re, time, threading, requests
from flask import Flask, request, jsonify
from datetime import datetime

app = Flask(__name__)
TG_TOKEN = "8617880782:AAEk8-vYA2uOR-YlNn5hKu0nWm1mO0wpNK0"
TG_URL = f"https://api.telegram.org/bot{TG_TOKEN}/"
GROUP_ID = -1002207534009
TIMEOUT = 90

class S:
    last_id = 0
s = S()

def send(text):
    r = requests.post(f"{TG_URL}sendMessage", json={"chat_id": GROUP_ID, "text": text}, timeout=10)
    return r.json().get("ok", False)

def updates(offset=0, timeout=5):
    try:
        r = requests.get(f"{TG_URL}getUpdates", params={"offset": offset, "timeout": timeout}, timeout=timeout+5)
        return r.json().get("result", [])
    except:
        return []

def polling():
    print("[TG] 監聽啟動...")
    while True:
        try:
            for u in updates(s.last_id + 1, 5):
                s.last_id = max(s.last_id, u["update_id"])
        except: pass
        time.sleep(1)

def find_apple():
    msgs = []
    for u in updates(s.last_id):
        s.last_id = max(s.last_id, u["update_id"])
        m = u.get("message") or u.get("edited_message")
        if not m or "text" not in m: continue
        if m.get("chat", {}).get("id") != GROUP_ID: continue
        t = m["text"]
        if "TEXT:" in t.upper() or "ACTION:" in t.upper():
            msgs.append(t)
            print(f"[Apple] {t[:50]}...")
    return msgs

def parse(text):
    txt = re.search(r'TEXT:\s*(.+?)(?:\n|$)', text, re.I|re.S)
    act = re.search(r'ACTION:\s*(\w+)', text, re.I)
    return {"text": txt.group(1).strip() if txt else "", "action": act.group(1).lower() if act else None}

@app.route("/ai", methods=["POST"])
def ai():
    d = request.json or {}
    msg = d.get("message", "")
    name = d.get("npc_name", "玩家")
    if not msg:
        return jsonify({"text": "", "action": ""})
    print(f"[OSgrid] {name}: {msg}")
    if not send(f"🎮 **{name}**：{msg}"):
        return jsonify({"text": "發送失敗", "action": ""})
    print("[等待 Apple 回覆...]")
    texts, action = [], None
    start = time.time()
    while time.time() - start < TIMEOUT:
        for m in find_apple():
            p = parse(m)
            if p["text"]: texts.append(p["text"])
            if p["action"] and not action: action = p["action"]
        if texts:
            time.sleep(2)
            break
        time.sleep(2)
    if not texts:
        return jsonify({"text": "（忙碌中）", "action": ""})
    return jsonify({"text": " | ".join(texts), "action": action or ""})

@app.route("/health")
def health():
    return jsonify({"status": "ok"})

if __name__ == "__main__":
    threading.Thread(target=polling, daemon=True).start()
    print("🎮 啟動！")
    app.run(host="0.0.0.0", port=9025, debug=False)

OSgrid → Python → Telegram Group ✅

#!/usr/bin/env python3
import os, re, time, threading, requests
from flask import Flask, request, jsonify
app = Flask(__name__)
TG_TOKEN = "8617880782:AAEk8-vYA2uOR-YlNn5hKu0nWm1mO0wpNK0"
TG_URL = f"https://api.telegram.org/bot{TG_TOKEN}/"
GROUP_ID = -1003522048132
TIMEOUT = 30
last_id = 0
def send(text):
    r = requests.post(f"{TG_URL}sendMessage", json={"chat_id": GROUP_ID, "text": text}, timeout=10)
    print(f"[TG] {r.json().get('ok')}")
    return r.json().get("ok", False)
def get_updates(offset=0, timeout=5):
    try:
        r = requests.get(f"{TG_URL}getUpdates", params={"offset": offset, "timeout": timeout}, timeout=timeout+5)
        return r.json().get("result", [])
    except Exception as e:
        print(f"[Error] {e}")
        return []
def polling():
    global last_id
    print("[Polling] 啟動")
    while True:
        try:
            for u in get_updates(last_id + 1, 5):
                last_id = max(last_id, u["update_id"])
                m = u.get("message", {})
                if m:
                    print(f"[收到] {m.get('chat',{}).get('id')}: {m.get('text','')[:30]}")
        except: pass
        time.sleep(1)
@app.route("/ai", methods=["POST"])
def ai():
    global last_id
    d = request.json or {}
    msg = d.get("message", "")
    name = d.get("npc_name", "玩家")
    if not msg:
        return jsonify({"text": "", "action": ""})
    print(f"[OSgrid] {name}: {msg}")
    send(f"🎮 **{name}**：{msg}")
    texts = []
    start = time.time()
    while time.time() - start < TIMEOUT:
        for u in get_updates(last_id + 1, 2):
            last_id = max(last_id, u["update_id"])
            m = u.get("message", {})
            if not m: continue
            t = m.get("text", "")
            chat = m.get("chat", {}).get("id", "")
            if chat == GROUP_ID and t and "🎮" not in t:
                print(f"[Jeff] {t}")
                texts.append(t)
                break
        if texts: break
        time.sleep(2)
    return jsonify({"text": " | ".join(texts) if texts else "（無回覆）", "action": ""})
@app.route("/health")
def health(): return jsonify({"status": "ok"})
if __name__ == "__main__":
    threading.Thread(target=polling, daemon=True).start()
    print("🎮 啟動！")
    app.run(host="0.0.0.0", port=9025, debug=False)

#!/usr/bin/env python3
import os, time, threading, requests
from flask import Flask, request, jsonify
app = Flask(__name__)

TG_TOKEN = "8617880782:AAEk8-vYA2uOR-YlNn5hKu0nWm1mO0wpNK0"
TG_URL = f"https://api.telegram.org/bot{TG_TOKEN}/"
GROUP_ID = -1003522048132
TIMEOUT = 30

msg_queue = []
last_update_id = 0

def send(text):
    r = requests.post(f"{TG_URL}sendMessage", json={"chat_id": GROUP_ID, "text": text}, timeout=10)
    return r.json().get("ok", False)

def poll():
    global last_update_id
    while True:
        try:
            r = requests.get(f"{TG_URL}getUpdates", params={"offset": last_update_id + 1, "timeout": 5}, timeout=10)
            for u in r.json().get("result", []):
                last_update_id = max(last_update_id, u["update_id"])
                m = u.get("message", {})
                if m and m.get("chat", {}).get("id") == GROUP_ID:
                    t = m.get("text", "")
                    if t and "🎮" not in t:
                        msg_queue.append(t)
                        print(f"[Queue] {t[:30]}...")
        except: pass
        time.sleep(1)

@app.route("/ai", methods=["POST"])
def ai():
    d = request.json or {}
    msg = d.get("message", "")
    name = d.get("npc_name", "玩家")
    if not msg:
        return jsonify({"text": "", "action": ""})
    print(f"[OSgrid] {name}: {msg}")
    send(f"🎮 **{name}**：{msg}")
    
    start = time.time()
    while time.time() - start < TIMEOUT:
        if msg_queue:
            reply = msg_queue.pop(0)
            print(f"[回覆] {reply}")
            return jsonify({"text": reply, "action": ""})
        time.sleep(1)
    return jsonify({"text": "（無回覆）", "action": ""})

@app.route("/health")
def health():
    return jsonify({"status": "ok"})

if __name__ == "__main__":
    threading.Thread(target=poll, daemon=True).start()
    print("🎮 啟動！")
    app.run(host="0.0.0.0", port=9025, debug=False)

OSgrid → Python → Telegram Group → 我（Apple）看到 → 我回覆 → Python 讀取 → OSgrid NPC 說出來

OSgrid 玩家說話 → LSL HTTP POST → Python Server → Telegram Group → Apple（我）看到 → 回覆 → Python 讀取 → 傳回 OSgrid NPC

#!/usr/bin/env python3
import os, time, threading, requests
from flask import Flask, request, jsonify

app = Flask(__name__)
TG_TOKEN = "8617880782:AAEk8-vYA2uOR-YlNn5hKu0nWm1mO0wpNK0"
TG_URL = f"https://api.telegram.org/bot{TG_TOKEN}/"
GROUP_ID = -1003522048132
TIMEOUT = 30
msg_queue = []
last_id = 0

def send(text):
    r = requests.post(f"{TG_URL}sendMessage", json={"chat_id": GROUP_ID, "text": text}, timeout=10)
    return r.json().get("ok", False)

def poll():
    global last_id
    while True:
        try:
            r = requests.get(f"{TG_URL}getUpdates", params={"offset": last_id + 1, "timeout": 5}, timeout=10)
            for u in r.json().get("result", []):
                last_id = max(last_id, u["update_id"])
                m = u.get("message", {})
                if m and m.get("chat", {}).get("id") == GROUP_ID:
                    t = m.get("text", "")
                    if t and "🎮" not in t:
                        msg_queue.append(t)
        except: pass
        time.sleep(1)

@app.route("/ai", methods=["POST"])
def ai():
    d = request.json or {}
    msg = d.get("message", "")
    name = d.get("npc_name", "玩家")
    if not msg:
        return jsonify({"text": "", "action": ""})
    send(f"🎮 **{name}**：{msg}")
    start = time.time()
    while time.time() - start < TIMEOUT:
        if msg_queue:
            return jsonify({"text": msg_queue.pop(0), "action": ""})
        time.sleep(1)
    return jsonify({"text": "（無回覆）", "action": ""})

@app.route("/health")
def health():
    return jsonify({"status": "ok"})

if __name__ == "__main__":
    threading.Thread(target=poll, daemon=True).start()
    print("🎮 啟動！")
    app.run(host="0.0.0.0", port=9025, debug=False)

#!/usr/bin/env python3
import os, time, threading, requests
from flask import Flask, request, jsonify
app = Flask(__name__)
TG_TOKEN = "8617880782:AAEk8-vYA2uOR-YlNn5hKu0nWm1mO0wpNK0"
TG_URL = f"https://api.telegram.org/bot{TG_TOKEN}/"
GROUP_ID = -1003522048132
TIMEOUT = 30
msg_queue = []
last_id = 0

def send(text):
    r = requests.post(f"{TG_URL}sendMessage", json={"chat_id": GROUP_ID, "text": text}, timeout=10)
    return r.json().get("ok", False)

def poll():
    global last_id
    while True:
        try:
            r = requests.get(f"{TG_URL}getUpdates", params={"offset": last_id + 1, "timeout": 5}, timeout=10)
            for u in r.json().get("result", []):
                last_id = max(last_id, u["update_id"])
                m = u.get("message", {})
                if m and m.get("chat", {}).get("id") == GROUP_ID:
                    t = m.get("text", "")
                    if t and "🎮" not in t:
                        msg_queue.append(t)
        except:
            pass
        time.sleep(1)

@app.route("/ai", methods=["POST"])
def ai():
    global last_id
    d = request.json or {}
    msg = d.get("message", "")
    name = d.get("npc_name", "玩家")
    # === 偵測點 ===
    print(f"[DEBUG] 收到的 JSON: {d}")
    print(f"[DEBUG] msg = '{msg}'")
    print(f"[DEBUG] name = '{name}'")
    # ==============
    if not msg:
        return jsonify({"text": "", "action": ""})
    print(f"[OSgrid] {name}: {msg}")
    send(f"🎮 **{name}**：{msg}")
    start = time.time()
    while time.time() - start < TIMEOUT:
        if msg_queue:
            reply = msg_queue.pop(0)
            print(f"[回覆] {reply}")
            return jsonify({"text": reply, "action": ""})
        time.sleep(1)
    return jsonify({"text": "（無回覆）", "action": ""})

@app.route("/health")
def health():
    return jsonify({"status": "ok"})

if __name__ == "__main__":
    threading.Thread(target=poll, daemon=True).start()
    print("🎮 啟動！")
    app.run(host="0.0.0.0", port=9025, debug=False)