pythonclaw 0.2.0__tar.gz → 0.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonclaw
-Version: 0.2.0
+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
@@ -76,7 +76,10 @@ Dynamic: license-file
   <a href="https://github.com/ericwang915/PythonClaw/actions/workflows/ci.yml">
     <img src="https://github.com/ericwang915/PythonClaw/actions/workflows/ci.yml/badge.svg" alt="CI">
   </a>
-  <img src="https://img.shields.io/badge/python-3.10+-blue?logo=python&logoColor=white" alt="Python 3.10+">
+  <a href="https://pypi.org/project/pythonclaw/">
+    <img src="https://img.shields.io/pypi/v/pythonclaw?color=blue" alt="PyPI">
+  </a>
+  <img src="https://img.shields.io/pypi/pyversions/pythonclaw" alt="Python">
   <a href="LICENSE">
     <img src="https://img.shields.io/github/license/ericwang915/PythonClaw" alt="MIT License">
   </a>

{pythonclaw-0.2.0 → pythonclaw-0.2.2}/README.md

@@ -13,7 +13,10 @@
   <a href="https://github.com/ericwang915/PythonClaw/actions/workflows/ci.yml">
     <img src="https://github.com/ericwang915/PythonClaw/actions/workflows/ci.yml/badge.svg" alt="CI">
   </a>
-  <img src="https://img.shields.io/badge/python-3.10+-blue?logo=python&logoColor=white" alt="Python 3.10+">
+  <a href="https://pypi.org/project/pythonclaw/">
+    <img src="https://img.shields.io/pypi/v/pythonclaw?color=blue" alt="PyPI">
+  </a>
+  <img src="https://img.shields.io/pypi/pyversions/pythonclaw" alt="Python">
   <a href="LICENSE">
     <img src="https://img.shields.io/github/license/ericwang915/PythonClaw" alt="MIT License">
   </a>

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythonclaw"
-version = "0.2.0"
+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.0 → 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.0"
+__version__ = "0.2.2"
 __all__ = [
     "Agent",
     "LLMProvider",

{pythonclaw-0.2.0 → 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.0 → pythonclaw-0.2.2}/pythonclaw/onboard.py

@@ -214,6 +214,54 @@ def _optional_keys(cfg: dict) -> None:
             print("  → SkillHub key set")
 
     print()
+    _channel_keys(cfg)
+
+
+def _channel_keys(cfg: dict) -> None:
+    print(_c("  Channels (press Enter to skip):", _DIM))
+    print()
+
+    channels = cfg.setdefault("channels", {})
+
+    # Telegram
+    tg = channels.setdefault("telegram", {"token": "", "allowedUsers": []})
+    tg_existing = tg.get("token", "")
+    if tg_existing:
+        masked = tg_existing[:6] + "****" + tg_existing[-4:] if len(tg_existing) > 10 else "****"
+        print(f"  Telegram Bot Token (current: {masked}, press Enter to keep)")
+    token = input("  Telegram Bot Token: ").strip()
+    if token:
+        tg["token"] = token
+        print("  → Telegram token set")
+    elif tg_existing:
+        print("  → Keeping existing Telegram token")
+
+    allowed = input("  Telegram Allowed User IDs (comma-separated, or Enter to allow all): ").strip()
+    if allowed:
+        tg["allowedUsers"] = [uid.strip() for uid in allowed.split(",") if uid.strip()]
+        print(f"  → {len(tg['allowedUsers'])} user(s) whitelisted")
+
+    print()
+
+    # Discord
+    dc = channels.setdefault("discord", {"token": "", "allowedUsers": [], "allowedChannels": []})
+    dc_existing = dc.get("token", "")
+    if dc_existing:
+        masked = dc_existing[:6] + "****" + dc_existing[-4:] if len(dc_existing) > 10 else "****"
+        print(f"  Discord Bot Token (current: {masked}, press Enter to keep)")
+    dc_token = input("  Discord Bot Token: ").strip()
+    if dc_token:
+        dc["token"] = dc_token
+        print("  → Discord token set")
+    elif dc_existing:
+        print("  → Keeping existing Discord token")
+
+    dc_channels = input("  Discord Allowed Channel IDs (comma-separated, or Enter to allow all): ").strip()
+    if dc_channels:
+        dc["allowedChannels"] = [ch.strip() for ch in dc_channels.split(",") if ch.strip()]
+        print(f"  → {len(dc['allowedChannels'])} channel(s) whitelisted")
+
+    print()
 
 
 def _validate_key(cfg: dict, provider: dict) -> 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.0 → 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.0 → 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 -->
@@ -266,6 +276,18 @@
             </div>
           </div>
 
+          <!-- Memory -->
+          <div class="section-card mb-6">
+            <h3 class="text-[.8125rem] font-semibold text-white mb-3 flex items-center gap-2">
+              <svg class="w-4 h-4 text-cyan-400" fill="none" stroke="currentColor" stroke-width="1.75" viewBox="0 0 24 24"><path d="M12 2a10 10 0 100 20 10 10 0 000-20z"/><path d="M12 6v6l4 2"/></svg>
+              Memory
+              <span id="memory-badge" class="text-[.625rem] text-gray-500 font-normal ml-1">0 entries</span>
+            </h3>
+            <div id="memory-content" class="max-h-[260px] overflow-y-auto chat-scroll">
+              <span class="text-[.75rem] text-gray-600 italic">No memories stored yet.</span>
+            </div>
+          </div>
+
           <!-- Tools & Quick Actions Row -->
           <div class="grid grid-cols-1 lg:grid-cols-3 gap-4">
             <!-- Tools List -->
@@ -479,6 +501,33 @@
               </div>
             </div>
 
+            <!-- Channels -->
+            <div class="cfg-section">
+              <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>
+                  <input id="cfg-tg-token" type="password" class="input-field">
+                </div>
+                <div>
+                  <label class="block text-xs text-gray-500 mb-1.5">Telegram Allowed Users</label>
+                  <input id="cfg-tg-users" type="text" placeholder="Comma-separated user IDs (blank = allow all)" class="input-field">
+                </div>
+                <div class="sm:col-span-2 mt-2">
+                  <label class="block text-xs text-gray-500 mb-1.5">Discord Bot Token</label>
+                  <input id="cfg-dc-token" type="password" class="input-field">
+                </div>
+                <div>
+                  <label class="block text-xs text-gray-500 mb-1.5">Discord Allowed Channels</label>
+                  <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 -->
             <div class="cfg-section">
               <h3 class="cfg-title">Web Dashboard</h3>
@@ -601,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();
@@ -653,6 +717,29 @@ async function refreshDashboard() {
       `).join('');
     }
   } catch (e) { console.error('Identity fetch:', e); }
+
+  try {
+    const res3 = await fetch('/api/memories');
+    const mem = await res3.json();
+    const container = document.getElementById('memory-content');
+    const badge = document.getElementById('memory-badge');
+    const entries = mem.memories || {};
+    const keys = Object.keys(entries);
+    badge.textContent = keys.length + ' entries';
+
+    if (keys.length === 0) {
+      container.innerHTML = '<span class="text-[.75rem] text-gray-600 italic">No memories stored yet. Chat with the agent to build memory.</span>';
+    } else {
+      container.innerHTML = '<div class="space-y-2">' + keys.map(k => {
+        const val = escapeHtml(String(entries[k]));
+        const preview = val.length > 200 ? val.substring(0, 200) + '...' : val;
+        return `<div class="px-3 py-2 rounded-lg bg-surface-800/50 border border-surface-700/30">
+          <div class="text-[.6875rem] text-cyan-400 font-medium mb-1">${escapeHtml(k)}</div>
+          <div class="text-[.75rem] text-gray-400 leading-relaxed whitespace-pre-wrap">${preview}</div>
+        </div>`;
+      }).join('') + '</div>';
+    }
+  } catch (e) { console.error('Memories fetch:', e); }
 }
 
 // ── Identity Editor ──────────────────────────────────────────────────────────
@@ -1008,12 +1095,38 @@ async function loadConfig() {
     ghTokenField.placeholder = secretsSet['skills.github.token']
       ? '(token is set — leave blank to keep)' : 'ghp_xxxxxxxxxx';
 
+    const channels = _rawConfig.channels || {};
+    const tgCfg = channels.telegram || {};
+    const tgTokenField = document.getElementById('cfg-tg-token');
+    tgTokenField.value = '';
+    tgTokenField.placeholder = secretsSet['channels.telegram.token'] ? '(token is set — leave blank to keep)' : 'Enter Telegram bot token';
+    document.getElementById('cfg-tg-users').value = (tgCfg.allowedUsers || []).join(', ');
+
+    const dcCfg = channels.discord || {};
+    const dcTokenField = document.getElementById('cfg-dc-token');
+    dcTokenField.value = '';
+    dcTokenField.placeholder = secretsSet['channels.discord.token'] ? '(token is set — leave blank to keep)' : 'Enter Discord bot token';
+    document.getElementById('cfg-dc-channels').value = (dcCfg.allowedChannels || []).join(', ');
+
     const web = _rawConfig.web || {};
     document.getElementById('cfg-web-host').value = web.host || '0.0.0.0';
     document.getElementById('cfg-web-port').value = web.port || 7788;
 
     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); }
 }
 
@@ -1090,6 +1203,19 @@ async function saveConfig() {
     const ghToken = document.getElementById('cfg-github-token').value.trim();
     if (ghToken) cfg.skills.github.token = ghToken;
 
+    if (!cfg.channels) cfg.channels = {};
+    if (!cfg.channels.telegram) cfg.channels.telegram = {};
+    const tgToken = document.getElementById('cfg-tg-token').value.trim();
+    if (tgToken) cfg.channels.telegram.token = tgToken;
+    const tgUsers = document.getElementById('cfg-tg-users').value.trim();
+    cfg.channels.telegram.allowedUsers = tgUsers ? tgUsers.split(',').map(s => s.trim()).filter(Boolean) : [];
+
+    if (!cfg.channels.discord) cfg.channels.discord = {};
+    const dcToken = document.getElementById('cfg-dc-token').value.trim();
+    if (dcToken) cfg.channels.discord.token = dcToken;
+    const dcChannels = document.getElementById('cfg-dc-channels').value.trim();
+    cfg.channels.discord.allowedChannels = dcChannels ? dcChannels.split(',').map(s => s.trim()).filter(Boolean) : [];
+
     if (!cfg.web) cfg.web = {};
     cfg.web.host = document.getElementById('cfg-web-host').value.trim() || '0.0.0.0';
     cfg.web.port = parseInt(document.getElementById('cfg-web-port').value) || 7788;

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonclaw
-Version: 0.2.0
+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
@@ -76,7 +76,10 @@ Dynamic: license-file
   <a href="https://github.com/ericwang915/PythonClaw/actions/workflows/ci.yml">
     <img src="https://github.com/ericwang915/PythonClaw/actions/workflows/ci.yml/badge.svg" alt="CI">
   </a>
-  <img src="https://img.shields.io/badge/python-3.10+-blue?logo=python&logoColor=white" alt="Python 3.10+">
+  <a href="https://pypi.org/project/pythonclaw/">
+    <img src="https://img.shields.io/pypi/v/pythonclaw?color=blue" alt="PyPI">
+  </a>
+  <img src="https://img.shields.io/pypi/pyversions/pythonclaw" alt="Python">
   <a href="LICENSE">
     <img src="https://img.shields.io/github/license/ericwang915/PythonClaw" alt="MIT License">
   </a>

pythonclaw-0.2.0/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.")