Update v2_gpt.py

v2_gpt.py

@@ -1,10 +1,4 @@
-# main.py
-"""
-CW_EMAIL / CW_PASSWORD で ChannelWorks にログインし、
-chatId=583391 のメッセージを ChatGPT プロキシに投げ、
-返答を /desk/channels/240996/groups/583391/messages へ送信する。
-"""
-
+# main_debug.py
 import json
 import os
 import random
@@ -12,12 +6,12 @@ import string
 import threading
 import time
 import traceback
+from datetime import datetime
 
 import requests
 
 from channel_auth import ChannelWorksClient
-from channel_msg import ChannelMessenger
-
+from channel_msg import ChannelMessenger   # ★ ライブラリ名修正
 
 # ---------------------------------------------------------------------------
 # 設定
@@ -25,8 +19,8 @@ from channel_msg import ChannelMessenger
 CW_EMAIL = os.environ["CW_EMAIL"]
 CW_PASSWORD = os.environ["CW_PASSWORD"]
 
-ROOM_ID = "240996"            # desk の channel id（URL の /channels/240996 の部分）
-TARGET_CHAT_ID = "583391"     # 監視したい chatId
+ROOM_ID = "240996"
+TARGET_CHAT_ID = "583391"
 GROUP_PATH = f"/groups/{TARGET_CHAT_ID}"
 
 GPT_API_URL = "https://izuemon-gpt-free-api.hf.space/v1/chat/completions"
@@ -39,18 +33,32 @@ CHANNEL_SEND_URL = (
     f"/groups/{TARGET_CHAT_ID}/messages"
 )
 
+# ★ デバッグログを全開にする
+LOG_LEVEL = ChannelWorksClient.LOG_DEBUG   # 2
+
 
 # ---------------------------------------------------------------------------
-# ユーティリティ
+# ロガー
 # ---------------------------------------------------------------------------
+def log(tag: str, msg: str) -> None:
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+    print(f"[{ts}] [{tag}] {msg}", flush=True)
+
+
+def log_block(tag: str, title: str, body: str) -> None:
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
+    print(f"\n[{ts}] [{tag}] ===== {title} =====", flush=True)
+    print(body, flush=True)
+    print(f"[{ts}] [{tag}] ===== /{title} =====\n", flush=True)
+
+
 def _make_request_id() -> str:
-    """desk-web-1791678445898qhbd のような形式の requestId を生成する。"""
     suffix = "".join(random.choices(string.ascii_lowercase + string.digits, k=4))
     return f"desk-web-{int(time.time() * 1000)}{suffix}"
 
 
 # ---------------------------------------------------------------------------
-# ChatGPT プロキシ呼び出し
+# ChatGPT プロキシ
 # ---------------------------------------------------------------------------
 def ask_gpt(text: str) -> str:
     payload = {
@@ -61,23 +69,38 @@ def ask_gpt(text: str) -> str:
         ],
         "stream": False,
     }
-    resp = requests.post(GPT_API_URL, json=payload, timeout=GPT_TIMEOUT)
+    log("GPT-REQ", f"POST {GPT_API_URL} model={GPT_MODEL}")
+    log_block("GPT-REQ-BODY", "request", json.dumps(payload, ensure_ascii=False, indent=2))
+
+    t0 = time.monotonic()
+    try:
+        resp = requests.post(GPT_API_URL, json=payload, timeout=GPT_TIMEOUT)
+    except Exception as exc:
+        log("GPT-ERR", f"通信例外: {exc!r}")
+        raise
+    dt = time.monotonic() - t0
+    log("GPT-RES", f"status={resp.status_code} elapsed={dt:.2f}s")
+    log_block("GPT-RES-BODY", "response", resp.text[:4000])
+
     resp.raise_for_status()
     data = resp.json()
-    # OpenAI 互換レスポンス
-    return data["choices"][0]["message"]["content"]
+    try:
+        return data["choices"][0]["message"]["content"]
+    except (KeyError, IndexError, TypeError) as exc:
+        log("GPT-ERR", f"レスポンス形式が想定外: {exc!r} / keys={list(data.keys())}")
+        raise
 
 
 # ---------------------------------------------------------------------------
-# Channel へのメッセージ送信
+# Channel 送信
 # ---------------------------------------------------------------------------
 def send_channel_message(client: ChannelWorksClient, text: str) -> requests.Response:
-    # 「最新の」トークンを毎回取得
     tokens = client.get_tokens() or {}
     x_account = tokens.get("x-account") or ""
     x_account_refresh = tokens.get("x-account-refresh") or ""
 
-    # 指定どおり Cookie に x-account / x-account-refresh / x-account-refresh-bound を含める
+    log("SEND-TOK", f"x-account={x_account[:24]}... refresh={x_account_refresh[:24]}...")
+
     cookie_parts = []
     if x_account:
         cookie_parts.append(f"x-account={x_account}")
@@ -111,12 +134,19 @@ def send_channel_message(client: ChannelWorksClient, text: str) -> requests.Resp
         "customPayload": None,
     }
 
+    log("SEND-REQ", f"POST {CHANNEL_SEND_URL}")
+    log_block("SEND-REQ-BODY", "request", json.dumps(body, ensure_ascii=False, indent=2))
+
+    t0 = time.monotonic()
     resp = requests.post(
         CHANNEL_SEND_URL,
         headers=headers,
         data=json.dumps(body, ensure_ascii=False).encode("utf-8"),
         timeout=30,
     )
+    dt = time.monotonic() - t0
+    log("SEND-RES", f"status={resp.status_code} elapsed={dt:.2f}s")
+    log_block("SEND-RES-BODY", "response", resp.text[:2000])
     return resp
 
 
@@ -124,93 +154,146 @@ def send_channel_message(client: ChannelWorksClient, text: str) -> requests.Resp
 # メイン
 # ---------------------------------------------------------------------------
 def main() -> None:
+    log("BOOT", f"CW_EMAIL={CW_EMAIL[:3]}*** / room_id={ROOM_ID} / target_chat_id={TARGET_CHAT_ID}")
+
+    # --- 1) ログイン ---
+    log("AUTH", "ChannelWorksClient 初期化")
     client = ChannelWorksClient(
         room_id=ROOM_ID,
         email=CW_EMAIL,
         password=CW_PASSWORD,
-        log_level=ChannelWorksClient.LOG_ERROR,
+        log_level=LOG_LEVEL,     # ★ DEBUG
     )
+    log("AUTH", "sign_in + boot 実行")
     client.login()
+    log("AUTH", "login() 完了")
+    tokens = client.get_tokens() or {}
+    log("AUTH", f"tokens: {[k for k, v in tokens.items() if v]}")
+
+    # ★ manager_id が解決できているか確認（未解決だと start() で落ちる）
+    log("AUTH", f"room_id(client)={getattr(client, 'room_id', None)}")
+    log("AUTH", f"_account_id={getattr(client, '_account_id', None)}")
+
     client.start_auto_touch()
+    log("AUTH", "auto_touch 開始")
 
-    # 自分の account id（自分が送ったメッセージを無視するため）
     my_account_id = str(getattr(client, "_account_id", "") or "")
+    log("AUTH", f"my_account_id={my_account_id}")
 
-    # 同一メッセージの多重処理防止
+    # --- 2) 受信ハンドラ ---
     seen_ids: set[str] = set()
     seen_lock = threading.Lock()
 
     def handle_message(text: str) -> None:
-        """ChatGPT に投げて、返答を Channel に送信する。"""
+        log("HANDLE", f"start text={text!r}")
         try:
             answer = ask_gpt(text)
         except Exception as exc:
-            print(f"[GPT ERROR] {exc!r}")
+            log("HANDLE-ERR", f"ask_gpt 失敗: {exc!r}")
             traceback.print_exc()
             return
+        log("HANDLE", f"answer={answer[:100]!r}...")
 
         try:
             resp = send_channel_message(client, answer)
             if 200 <= resp.status_code < 300:
-                print(f"[SEND OK] status={resp.status_code}")
+                log("SEND-OK", f"status={resp.status_code}")
             else:
-                print(f"[SEND NG] status={resp.status_code} body={resp.text[:300]}")
+                log("SEND-NG", f"status={resp.status_code} body={resp.text[:300]}")
         except Exception as exc:
-            print(f"[SEND ERROR] {exc!r}")
+            log("SEND-ERR", f"{exc!r}")
             traceback.print_exc()
 
     def on_push(wrapper: dict) -> None:
-        # create イベントのみ対象
+        # ★ まず何が来たか全部出す
+        log_block(
+            "PUSH-RAW",
+            f"event={wrapper.get('event')} type={wrapper.get('type')}",
+            json.dumps(wrapper, ensure_ascii=False, indent=2)[:4000],
+        )
+
         if wrapper.get("event") != "create":
+            log("PUSH-SKIP", f"event != create ({wrapper.get('event')})")
             return
+
         entity = wrapper.get("entity") or {}
+        chat_id = str(entity.get("chatId") or "")
+        person_id = str(entity.get("personId") or "")
+        msg_id = entity.get("id") or ""
+        plain = entity.get("plainText") or ""
+
+        log(
+            "PUSH-CHK",
+            f"chatId={chat_id!r} (want {TARGET_CHAT_ID!r}) "
+            f"personId={person_id!r} (self {my_account_id!r}) "
+            f"msgId={msg_id!r} plainText={plain!r}",
+        )
 
-        # chatId フィルタ
-        if str(entity.get("chatId") or "") != TARGET_CHAT_ID:
+        if chat_id != TARGET_CHAT_ID:
+            log("PUSH-SKIP", f"chatId mismatch: got={chat_id!r} want={TARGET_CHAT_ID!r}")
             return
 
-        # 自分の送信メッセージは無視
-        person_id = str(entity.get("personId") or "")
         if person_id and my_account_id and person_id == my_account_id:
+            log("PUSH-SKIP", "自分のメッセージのため無視")
             return
 
-        # メッセージ ID で多重処理防止
-        msg_id = entity.get("id") or ""
         if msg_id:
             with seen_lock:
                 if msg_id in seen_ids:
+                    log("PUSH-SKIP", f"既出 msgId={msg_id!r}")
                     return
                 seen_ids.add(msg_id)
                 if len(seen_ids) > 2000:
                     seen_ids.clear()
 
-        text = entity.get("plainText") or ""
-        if not text.strip():
+        if not plain.strip():
+            log("PUSH-SKIP", "plainText が空")
             return
 
-        print(f"[RECV] chatId={entity.get('chatId')} personId={person_id}: {text!r}")
-        # WS ループをブロックしないよう別スレッドで処理
-        threading.Thread(
-            target=handle_message, args=(text,), daemon=True
-        ).start()
+        log("PUSH-HIT", f"処理対象: {plain!r}")
+        threading.Thread(target=handle_message, args=(plain,), daemon=True).start()
 
+    # --- 3) Messenger 起動 ---
+    log("WS", "ChannelMessenger 初期化")
     messenger = ChannelMessenger(
         client=client,
-        channel_id=ROOM_ID,      # /channels/240996
-        # manager_id は room 情報から自動解決させる（指定してもよい）
-        group_path=GROUP_PATH,   # /groups/583391
-        log_level=ChannelMessenger.LOG_ERROR,
+        channel_id=ROOM_ID,
+        group_path=GROUP_PATH,
+        log_level=LOG_LEVEL,     # ★ DEBUG
         on_push=on_push,
     )
 
-    messenger.start()
+    log("WS", "start() 呼び出し（WS 接続開始）")
+    try:
+        messenger.start()
+    except Exception as exc:
+        log("WS-ERR", f"start() 失敗: {exc!r}")
+        traceback.print_exc()
+        return
+
+    log("WS", f"start() 完了 running={messenger.is_running()}")
+
+    # ★ 30 秒ごとに生存確認（WS が死んでいないか）
+    def watchdog() -> None:
+        while True:
+            time.sleep(30)
+            if not messenger.is_running():
+                log("WATCH", "ChannelMessenger が停止しています！")
+                break
+            log("WATCH", "alive")
+
+    threading.Thread(target=watchdog, daemon=True).start()
+
     try:
+        log("WS", "wait() で受信待機")
         messenger.wait()
     except KeyboardInterrupt:
-        print("KeyboardInterrupt: 終了します。")
+        log("WS", "KeyboardInterrupt")
     finally:
+        log("WS", "停止処理")
         messenger.stop()
         client.stop_auto_touch()
+        log("WS", "終了")
 
 
 if __name__ == "__main__":