pythonclaw 0.2.1__tar.gz → 0.2.2__tar.gz

{pythonclaw-0.2.1/pythonclaw.egg-info → pythonclaw-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonclaw
-Version: 0.2.1
+Version: 0.2.2
 Summary: OpenClaw reimagined in pure Python — autonomous AI agent with memory, RAG, skills, web dashboard, and multi-channel support.
 Author-email: Eric Wang <wangchen2007915@gmail.com>
 License: MIT

{pythonclaw-0.2.1 → pythonclaw-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythonclaw"
-version = "0.2.1"
+version = "0.2.2"
 description = "OpenClaw reimagined in pure Python — autonomous AI agent with memory, RAG, skills, web dashboard, and multi-channel support."
 readme = "README.md"
 license = {text = "MIT"}

{pythonclaw-0.2.1 → pythonclaw-0.2.2}/pythonclaw/__init__.py

@@ -6,7 +6,7 @@ from .core.llm.base import LLMProvider
 from .core.llm.openai_compatible import OpenAICompatibleProvider
 from .init import init
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"
 __all__ = [
     "Agent",
     "LLMProvider",

{pythonclaw-0.2.1 → pythonclaw-0.2.2}/pythonclaw/main.py

@@ -149,28 +149,46 @@ def _run_foreground(args) -> None:
         format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
     )
 
-    if channels:
-        # Run web + channels together
-        from .server import run_server
-        print(f"[PythonClaw] Starting (web + {', '.join(channels)})...")
-        asyncio.run(run_server(provider, channels=channels))
-    else:
-        # Web-only
-        try:
-            import uvicorn
-        except ImportError:
-            print("Error: Web mode requires 'fastapi' and 'uvicorn'.")
-            print("Install with: pip install pythonclaw[web]")
-            return
+    try:
+        import uvicorn
+    except ImportError:
+        print("Error: Web mode requires 'fastapi' and 'uvicorn'.")
+        print("Install with: pip install pythonclaw[web]")
+        return
 
-        from .web.app import create_app
+    from .web.app import create_app
 
-        host = config.get_str("web", "host", default="0.0.0.0")
-        port = config.get_int("web", "port", default=7788)
+    host = config.get_str("web", "host", default="0.0.0.0")
+    port = config.get_int("web", "port", default=7788)
 
-        app = create_app(provider, build_provider_fn=_build_provider)
-        print(f"[PythonClaw] Web dashboard: http://localhost:{port}")
-        uvicorn.run(app, host=host, port=port, log_level="info")
+    app = create_app(provider, build_provider_fn=_build_provider)
+
+    ch_to_start = channels or _detect_configured_channels()
+    if ch_to_start:
+        from .server import start_channels
+        from .web import app as web_app_module
+        label = "explicit" if channels else "auto-detected"
+        print(f"[PythonClaw] Channels ({label}): {', '.join(ch_to_start)}")
+
+        @app.on_event("startup")
+        async def _start_channels():
+            bots = await start_channels(provider, ch_to_start)
+            web_app_module._active_bots.extend(bots)
+
+    print(f"[PythonClaw] Web dashboard: http://localhost:{port}")
+    uvicorn.run(app, host=host, port=port, log_level="info")
+
+
+def _detect_configured_channels() -> list[str]:
+    """Return channel names that have a token configured."""
+    found = []
+    tg_token = config.get_str("channels", "telegram", "token", default="")
+    if tg_token:
+        found.append("telegram")
+    dc_token = config.get_str("channels", "discord", "token", default="")
+    if dc_token:
+        found.append("discord")
+    return found
 
 
 def _cmd_stop(args) -> None:

pythonclaw-0.2.2/pythonclaw/server.py

@@ -0,0 +1,125 @@
+"""
+Daemon server for PythonClaw — multi-channel mode.
+
+Supports Telegram and Discord channels, individually or combined.
+The web dashboard always runs; channels are started alongside it.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import signal
+
+from .core.llm.base import LLMProvider
+from .core.persistent_agent import PersistentAgent
+from .core.session_store import SessionStore
+from .scheduler.cron import CronScheduler
+from .session_manager import SessionManager
+
+logger = logging.getLogger(__name__)
+
+
+async def start_channels(
+    provider: LLMProvider,
+    channels: list[str],
+) -> list:
+    """Start messaging channels (Telegram, Discord) as background tasks.
+
+    Returns the list of successfully started bot objects.
+    Safe to call during FastAPI startup — failures are logged, not raised.
+    """
+    store = SessionStore()
+    session_manager = SessionManager(agent_factory=lambda sid: None, store=store)
+
+    jobs_path = os.path.join("context", "cron", "jobs.yaml")
+    scheduler = CronScheduler(
+        session_manager=session_manager,
+        jobs_path=jobs_path,
+    )
+
+    def agent_factory(session_id: str) -> PersistentAgent:
+        return PersistentAgent(
+            provider=provider,
+            store=store,
+            session_id=session_id,
+            cron_manager=scheduler,
+            verbose=False,
+        )
+
+    session_manager.set_factory(agent_factory)
+
+    active_bots: list = []
+
+    if "telegram" in channels:
+        try:
+            from .channels.telegram_bot import create_bot_from_env
+            bot = create_bot_from_env(session_manager)
+            scheduler._telegram_bot = bot
+            await bot.start_async()
+            active_bots.append(bot)
+            logger.info("[Server] Telegram bot started.")
+        except Exception as exc:
+            logger.warning("[Server] Telegram channel failed to start: %s", exc)
+
+    if "discord" in channels:
+        try:
+            from .channels.discord_bot import create_bot_from_env as create_discord
+            discord_bot = create_discord(session_manager)
+            asyncio.create_task(discord_bot.start_async())
+            active_bots.append(discord_bot)
+            logger.info("[Server] Discord bot started.")
+        except Exception as exc:
+            logger.warning("[Server] Discord channel failed to start: %s", exc)
+
+    if active_bots:
+        scheduler.start()
+        logger.info("[Server] Channels running: %s", ", ".join(channels))
+    else:
+        logger.warning("[Server] No channels started — check tokens in pythonclaw.json.")
+
+    return active_bots
+
+
+async def run_server(
+    provider: LLMProvider,
+    channels: list[str] | None = None,
+) -> None:
+    """Standalone server entry point (channels only, no web).
+
+    Kept for backward compatibility.  Prefer using ``start_channels``
+    together with the web dashboard in ``_run_foreground``.
+    """
+    if channels is None:
+        channels = ["telegram"]
+
+    active_bots = await start_channels(provider, channels)
+
+    if not active_bots:
+        logger.error("[Server] No channels started. Exiting.")
+        return
+
+    stop_event = asyncio.Event()
+
+    def _signal_handler() -> None:
+        logger.info("[Server] Shutdown signal received.")
+        stop_event.set()
+
+    loop = asyncio.get_running_loop()
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        try:
+            loop.add_signal_handler(sig, _signal_handler)
+        except (NotImplementedError, OSError):
+            pass
+
+    try:
+        await stop_event.wait()
+    except (KeyboardInterrupt, asyncio.CancelledError):
+        pass
+    finally:
+        logger.info("[Server] Shutting down...")
+        for bot in active_bots:
+            if hasattr(bot, 'stop_async'):
+                await bot.stop_async()
+        logger.info("[Server] Shutdown complete.")

{pythonclaw-0.2.1 → pythonclaw-0.2.2}/pythonclaw/web/app.py

@@ -37,6 +37,7 @@ _provider: LLMProvider | None = None
 _store: SessionStore | None = None
 _start_time: float = 0.0
 _build_provider_fn = None
+_active_bots: list = []
 
 WEB_SESSION_ID = "web:dashboard"
 
@@ -73,6 +74,8 @@ def create_app(provider: LLMProvider | None, *, build_provider_fn=None) -> FastA
     app.add_api_route("/api/skillhub/search", _api_skillhub_search, methods=["POST"])
     app.add_api_route("/api/skillhub/browse", _api_skillhub_browse, methods=["GET"])
     app.add_api_route("/api/skillhub/install", _api_skillhub_install, methods=["POST"])
+    app.add_api_route("/api/channels", _api_channels_status, methods=["GET"])
+    app.add_api_route("/api/channels/restart", _api_channels_restart, methods=["POST"])
     app.add_websocket_route("/ws/chat", _ws_chat)
 
     return app
@@ -226,7 +229,14 @@ async def _api_config_save(request: Request):
             logger.warning("[Web] Provider rebuild failed: %s", exc)
             _provider = None
 
-    return {"ok": True, "configPath": str(cfg_path), "providerReady": _provider is not None}
+    channels_started = await _maybe_start_channels()
+
+    return {
+        "ok": True,
+        "configPath": str(cfg_path),
+        "providerReady": _provider is not None,
+        "channelsStarted": channels_started,
+    }
 
 
 async def _api_skills():
@@ -507,6 +517,81 @@ async def _api_skillhub_install(request: Request):
         return JSONResponse({"ok": False, "error": str(exc)}, status_code=500)
 
 
+async def _maybe_start_channels() -> list[str]:
+    """Start channels whose tokens are now configured but not yet running."""
+    global _active_bots
+    if _provider is None:
+        return []
+
+    wanted = []
+    tg_token = config.get_str("channels", "telegram", "token", default="")
+    if tg_token:
+        wanted.append("telegram")
+    dc_token = config.get_str("channels", "discord", "token", default="")
+    if dc_token:
+        wanted.append("discord")
+
+    if not wanted:
+        return []
+
+    running_types = set()
+    for bot in _active_bots:
+        cls_name = type(bot).__name__.lower()
+        if "telegram" in cls_name:
+            running_types.add("telegram")
+        elif "discord" in cls_name:
+            running_types.add("discord")
+
+    to_start = [ch for ch in wanted if ch not in running_types]
+    if not to_start:
+        return list(running_types)
+
+    try:
+        from ..server import start_channels
+        new_bots = await start_channels(_provider, to_start)
+        _active_bots.extend(new_bots)
+        return [ch for ch in wanted if ch in running_types or ch in to_start]
+    except Exception as exc:
+        logger.warning("[Web] Channel start failed: %s", exc)
+        return list(running_types)
+
+
+async def _api_channels_status():
+    """Return status of messaging channels."""
+    channels = []
+    for bot in _active_bots:
+        cls_name = type(bot).__name__
+        ch_type = "telegram" if "Telegram" in cls_name else "discord" if "Discord" in cls_name else cls_name
+        channels.append({"type": ch_type, "running": True})
+
+    tg_token = config.get_str("channels", "telegram", "token", default="")
+    dc_token = config.get_str("channels", "discord", "token", default="")
+    running_types = {c["type"] for c in channels}
+
+    if tg_token and "telegram" not in running_types:
+        channels.append({"type": "telegram", "running": False, "tokenSet": True})
+    if dc_token and "discord" not in running_types:
+        channels.append({"type": "discord", "running": False, "tokenSet": True})
+
+    return {"channels": channels}
+
+
+async def _api_channels_restart(request: Request):
+    """Stop and restart all configured channels."""
+    global _active_bots
+
+    for bot in _active_bots:
+        if hasattr(bot, "stop_async"):
+            try:
+                await bot.stop_async()
+            except Exception:
+                pass
+    _active_bots = []
+
+    started = await _maybe_start_channels()
+    return {"ok": True, "channels": started}
+
+
 def _reload_agent_identity() -> None:
     """Reload the agent's soul/persona from disk without full reset."""
     global _agent

{pythonclaw-0.2.1 → pythonclaw-0.2.2}/pythonclaw/web/static/index.html

@@ -209,6 +209,16 @@
                 <div id="stat-history" class="text-[.6875rem] text-gray-500">0 msgs in history</div>
               </div>
             </div>
+            <div class="stat-card section-card flex items-start gap-3.5">
+              <div class="w-9 h-9 rounded-lg bg-cyan-500/15 flex items-center justify-center shrink-0 mt-0.5">
+                <svg class="w-4.5 h-4.5 text-cyan-400" fill="none" stroke="currentColor" stroke-width="1.75" viewBox="0 0 24 24"><path d="M21 15a2 2 0 01-2 2H7l-4 4V5a2 2 0 012-2h14a2 2 0 012 2z"/></svg>
+              </div>
+              <div class="min-w-0">
+                <div class="text-[.6875rem] text-gray-500 font-medium uppercase tracking-wider mb-1">Channels</div>
+                <div id="stat-channels" class="text-base font-semibold text-white">Web only</div>
+                <div id="stat-channels-detail" class="text-[.6875rem] text-gray-500">web dashboard</div>
+              </div>
+            </div>
           </div>
 
           <!-- Identity & Status Row -->
@@ -493,7 +503,10 @@
 
             <!-- Channels -->
             <div class="cfg-section">
-              <h3 class="cfg-title">Channels</h3>
+              <h3 class="cfg-title flex items-center gap-2">
+                Channels
+                <span id="cfg-channel-status" class="text-[.625rem] font-normal text-gray-500"></span>
+              </h3>
               <div class="grid grid-cols-1 sm:grid-cols-2 gap-x-6 gap-y-4">
                 <div class="sm:col-span-2">
                   <label class="block text-xs text-gray-500 mb-1.5">Telegram Bot Token</label>
@@ -512,6 +525,7 @@
                   <input id="cfg-dc-channels" type="text" placeholder="Comma-separated channel IDs (blank = allow all)" class="input-field">
                 </div>
               </div>
+              <p class="text-[.6875rem] text-gray-600 mt-3">Channels auto-start after saving. Tokens are stored securely.</p>
             </div>
 
             <!-- Web Dashboard -->
@@ -636,6 +650,21 @@ async function refreshDashboard() {
     banner.classList.toggle('hidden', d.providerReady !== false);
   } catch (e) { console.error('Status fetch:', e); }
 
+  try {
+    const chRes = await fetch('/api/channels');
+    const chData = await chRes.json();
+    const running = (chData.channels || []).filter(c => c.running).map(c => c.type);
+    const chEl = document.getElementById('stat-channels');
+    const chDetailEl = document.getElementById('stat-channels-detail');
+    if (running.length > 0) {
+      chEl.textContent = (running.length + 1) + ' active';
+      chDetailEl.textContent = 'web + ' + running.join(', ');
+    } else {
+      chEl.textContent = 'Web only';
+      chDetailEl.textContent = 'web dashboard';
+    }
+  } catch (e) {}
+
   try {
     const res2 = await fetch('/api/identity');
     const id = await res2.json();
@@ -1085,6 +1114,19 @@ async function loadConfig() {
 
     document.getElementById('cfg-json-raw').value = JSON.stringify(_rawConfig, null, 2);
     document.getElementById('config-save-status').textContent = '';
+
+    // Channel status
+    try {
+      const chRes = await fetch('/api/channels');
+      const chData = await chRes.json();
+      const statusEl = document.getElementById('cfg-channel-status');
+      const running = (chData.channels || []).filter(c => c.running).map(c => c.type);
+      if (running.length > 0) {
+        statusEl.innerHTML = '<span class="text-accent-green">● ' + running.join(', ') + ' running</span>';
+      } else {
+        statusEl.textContent = '';
+      }
+    } catch (e) {}
   } catch (e) { console.error('Config fetch:', e); }
 }
 

{pythonclaw-0.2.1 → pythonclaw-0.2.2/pythonclaw.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonclaw
-Version: 0.2.1
+Version: 0.2.2
 Summary: OpenClaw reimagined in pure Python — autonomous AI agent with memory, RAG, skills, web dashboard, and multi-channel support.
 Author-email: Eric Wang <wangchen2007915@gmail.com>
 License: MIT

pythonclaw-0.2.1/pythonclaw/server.py

@@ -1,145 +0,0 @@
-"""
-Daemon server for PythonClaw — multi-channel mode.
-
-Supports Telegram and Discord channels, individually or combined.
-
-Architecture
-------------
-                    +----------------------------------------+
-                    |          SessionManager                 |
-                    |  "{channel}:{id}" → Agent               |
-                    |  "cron:{job_id}"  → Agent               |
-                    |  (Markdown-backed via SessionStore)      |
-                    +----------------------------------------+
-                               |
-          +--------------------+--------------------+
-          |                    |                    |
-    TelegramBot          CronScheduler       HeartbeatMonitor
-    DiscordBot           static + dynamic
-                         jobs
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import os
-import signal
-
-from .core.llm.base import LLMProvider
-from .core.persistent_agent import PersistentAgent
-from .core.session_store import SessionStore
-from .scheduler.cron import CronScheduler
-from .scheduler.heartbeat import create_heartbeat
-from .session_manager import SessionManager
-
-logger = logging.getLogger(__name__)
-
-
-async def run_server(
-    provider: LLMProvider,
-    channels: list[str] | None = None,
-) -> None:
-    """
-    Main entry point for daemon mode.
-
-    Parameters
-    ----------
-    provider  : the LLM provider to use
-    channels  : list of channels to start, e.g. ["telegram", "discord"].
-                Defaults to ["telegram"] for backward compatibility.
-    """
-    if channels is None:
-        channels = ["telegram"]
-
-    # ── 1. Session store (Markdown persistence) ───────────────────────────────
-    store = SessionStore()
-    logger.info("[Server] SessionStore initialised at '%s'", store.base_dir)
-
-    # ── 2. SessionManager (placeholder factory, updated below) ────────────────
-    session_manager = SessionManager(agent_factory=lambda sid: None, store=store)
-
-    # ── 3. CronScheduler ─────────────────────────────────────────────────────
-    jobs_path = os.path.join("context", "cron", "jobs.yaml")
-    scheduler = CronScheduler(
-        session_manager=session_manager,
-        jobs_path=jobs_path,
-    )
-
-    # ── 4. Real agent factory ─────────────────────────────────────────────────
-    def agent_factory(session_id: str) -> PersistentAgent:
-        return PersistentAgent(
-            provider=provider,
-            store=store,
-            session_id=session_id,
-            cron_manager=scheduler,
-            verbose=False,
-        )
-
-    session_manager.set_factory(agent_factory)
-
-    # ── 5. Start channels ─────────────────────────────────────────────────────
-    active_bots: list = []
-
-    if "telegram" in channels:
-        try:
-            from .channels.telegram_bot import create_bot_from_env
-            bot = create_bot_from_env(session_manager)
-            scheduler._telegram_bot = bot
-            await bot.start_async()
-            active_bots.append(bot)
-            logger.info("[Server] Telegram bot started.")
-        except (ValueError, ImportError) as exc:
-            logger.warning("[Server] Telegram skipped: %s", exc)
-
-    if "discord" in channels:
-        try:
-            from .channels.discord_bot import create_bot_from_env as create_discord
-            discord_bot = create_discord(session_manager)
-            asyncio.create_task(discord_bot.start_async())
-            active_bots.append(discord_bot)
-            logger.info("[Server] Discord bot started.")
-        except (ValueError, ImportError) as exc:
-            logger.warning("[Server] Discord skipped: %s", exc)
-
-    if not active_bots:
-        logger.error("[Server] No channels started. Check your pythonclaw.json configuration.")
-        return
-
-    # ── 6. Start scheduler ────────────────────────────────────────────────────
-    scheduler.start()
-
-    # ── 7. Heartbeat monitor ──────────────────────────────────────────────────
-    telegram_bot = next((b for b in active_bots if hasattr(b, '_app')), None)
-    heartbeat = create_heartbeat(provider=provider, telegram_bot=telegram_bot)
-    await heartbeat.start()
-
-    logger.info("[Server] All subsystems running (%s). Press Ctrl-C to stop.",
-                ", ".join(channels))
-
-    # ── Graceful shutdown ─────────────────────────────────────────────────────
-    stop_event = asyncio.Event()
-
-    def _signal_handler() -> None:
-        logger.info("[Server] Shutdown signal received.")
-        stop_event.set()
-
-    loop = asyncio.get_running_loop()
-    for sig in (signal.SIGINT, signal.SIGTERM):
-        try:
-            loop.add_signal_handler(sig, _signal_handler)
-        except (NotImplementedError, OSError):
-            pass
-
-    try:
-        await stop_event.wait()
-    except (KeyboardInterrupt, asyncio.CancelledError):
-        pass
-    finally:
-        logger.info("[Server] Shutting down subsystems...")
-        await heartbeat.stop()
-        scheduler.stop()
-        for bot in active_bots:
-            if hasattr(bot, 'stop_async'):
-                await bot.stop_async()
-        logger.info("[Server] Shutdown complete.")