pythonclaw 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

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/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/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/server.py

@@ -2,21 +2,7 @@
 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
+The web dashboard always runs; channels are started alongside it.
 """
 
 from __future__ import annotations
@@ -30,43 +16,29 @@ 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(
+async def start_channels(
     provider: LLMProvider,
-    channels: list[str] | None = None,
-) -> None:
-    """
-    Main entry point for daemon mode.
+    channels: list[str],
+) -> list:
+    """Start messaging channels (Telegram, Discord) as background tasks.
 
-    Parameters
-    ----------
-    provider  : the LLM provider to use
-    channels  : list of channels to start, e.g. ["telegram", "discord"].
-                Defaults to ["telegram"] for backward compatibility.
+    Returns the list of successfully started bot objects.
+    Safe to call during FastAPI startup — failures are logged, not raised.
     """
-    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,
@@ -78,7 +50,6 @@ async def run_server(
 
     session_manager.set_factory(agent_factory)
 
-    # ── 5. Start channels ─────────────────────────────────────────────────────
     active_bots: list = []
 
     if "telegram" in channels:
@@ -89,8 +60,8 @@ async def run_server(
             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)
+        except Exception as exc:
+            logger.warning("[Server] Telegram channel failed to start: %s", exc)
 
     if "discord" in channels:
         try:
@@ -99,25 +70,36 @@ async def run_server(
             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)
+        except Exception as exc:
+            logger.warning("[Server] Discord channel failed to start: %s", exc)
 
-    if not active_bots:
-        logger.error("[Server] No channels started. Check your pythonclaw.json configuration.")
-        return
+    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.")
 
-    # ── 6. Start scheduler ────────────────────────────────────────────────────
-    scheduler.start()
+    return active_bots
 
-    # ── 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))
+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
 
-    # ── Graceful shutdown ─────────────────────────────────────────────────────
     stop_event = asyncio.Event()
 
     def _signal_handler() -> None:
@@ -136,9 +118,7 @@ async def run_server(
     except (KeyboardInterrupt, asyncio.CancelledError):
         pass
     finally:
-        logger.info("[Server] Shutting down subsystems...")
-        await heartbeat.stop()
-        scheduler.stop()
+        logger.info("[Server] Shutting down...")
         for bot in active_bots:
             if hasattr(bot, 'stop_async'):
                 await bot.stop_async()

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/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.dist-info → pythonclaw-0.2.2.dist-info}/METADATA

@@ -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.dist-info → pythonclaw-0.2.2.dist-info}/RECORD

@@ -1,11 +1,11 @@
-pythonclaw/__init__.py,sha256=d5a_7oWlgUkxPsnWLDqIfTpnOgCRyplGOm0Hc8tldv4,389
+pythonclaw/__init__.py,sha256=WUtCQQOhI2PW7Bj-z9y7VqLQ2mCAklPE9kbIAv2ziwo,389
 pythonclaw/__main__.py,sha256=8q42hSuG6znq4wWXSPDmCtmG77SF7P_23hjwaRb-V9I,123
 pythonclaw/config.py,sha256=QreP_tBvUTK6UD2wsEMgBX51Tzb6KuIjznQQFgkKVOI,5395
 pythonclaw/daemon.py,sha256=i07DGJd-REzSW6tHQIEgHpx3Is44ZcxjCcUxFV8_p0c,6519
 pythonclaw/init.py,sha256=SMPaW-esuUeMIEYAEVC8Kl5jxmGz_BKgfm-ay5EMbe8,2311
-pythonclaw/main.py,sha256=AmLNLwJ9RQ75_I-C86yvJjiBu-c1WcoPufVTfZtjfgQ,17490
-pythonclaw/onboard.py,sha256=yVRbgfaCfSsJfLEKTgrc7Ms6upo6w-ev-KWN_BbmeYU,9806
-pythonclaw/server.py,sha256=1i_qS9FF36PTwCxhBb4nIdl5gq0OrKUTipHy0W-lasQ,5879
+pythonclaw/main.py,sha256=Fo1jGbRFngwcecphF7X_dN8DMspFYzG39DkpLd4-KZs,18071
+pythonclaw/onboard.py,sha256=mzGhHmVghoveSc9Cku0YxOA_0O4blXRim12GIqJ2JVM,11693
+pythonclaw/server.py,sha256=2rHC9xJXeur4qoA8UCmHN3u7oooB3nSYByjZcsxdEyQ,3857
 pythonclaw/session_manager.py,sha256=oWxvyztYqAwgkG5ofJYiXf0XHR8NKD8wmF7FmWsetM8,3969
 pythonclaw/channels/discord_bot.py,sha256=ToEs5wm0woo7pjMfjyiVDvBjt2nxQ9MfyJU9g5U5o1w,9293
 pythonclaw/channels/telegram_bot.py,sha256=S2GSQQHQnUDRemhj2NMUgMxTbTTIsACwquMdIpdVUJw,9959
@@ -100,13 +100,13 @@ pythonclaw/templates/skills/web/CATEGORY.md,sha256=sCfrbWk9kfbWAv5_wkB7J2Fzz1I7f
 pythonclaw/templates/skills/web/tavily/SKILL.md,sha256=j9chgkhxHEVNpnZv0fBLp8vDtZmqfiS577E5OWda2U4,2018
 pythonclaw/templates/soul/SOUL.md,sha256=DskXNm-rKTG1pG_k17CEjOBfcC-7YlVVgPAoRHGQDXs,2182
 pythonclaw/web/__init__.py,sha256=ZgKF2tEAcpGnM22EC1CpNKtV4PQ8RbHw2qIqhw7i3UM,86
-pythonclaw/web/app.py,sha256=qu1SzZNHVEkX626PVV8015A6iyLkMsZsLMBiwIRcXaE,21236
+pythonclaw/web/app.py,sha256=YfaPbq2D6zgYyuY0UsA-uJQgPy_-xbngd2V4Qcnak7o,24049
 pythonclaw/web/static/favicon.png,sha256=zJA13uE8mSe6lOlR5NyAhiOmnZkfv7ZlBbSBNCH7iTM,2557
-pythonclaw/web/static/index.html,sha256=C__bG5cHExCnfwSqFxe5wbvSBHc3qzxJN2l3M0jk2Ag,68777
+pythonclaw/web/static/index.html,sha256=voy3AbwE0ftNL7nnFFqfN920cMaL0D7twwwQeoGEhnU,75713
 pythonclaw/web/static/logo.png,sha256=h7v0HHllD23FtmCL2UvjjTDt0UgqKjGy5jOhI3rb7lM,28359
-pythonclaw-0.2.0.dist-info/licenses/LICENSE,sha256=wbYsm5Ofe8cnxHgWSnSG1vUJDNiY1DIeTyxHSbo1HqM,1066
-pythonclaw-0.2.0.dist-info/METADATA,sha256=wJv00oSdDtewuUZAliZYr6atobfK14d9b2iARwRatcA,14481
-pythonclaw-0.2.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
-pythonclaw-0.2.0.dist-info/entry_points.txt,sha256=4uGCuBw-id_22IRdkoxPVOOcwgiPX5lNEpD1XKQWE4I,52
-pythonclaw-0.2.0.dist-info/top_level.txt,sha256=S_lM2VH3gP3UeZbSWHXIrBOCNtoqn5pk491IAzgsV7M,11
-pythonclaw-0.2.0.dist-info/RECORD,,
+pythonclaw-0.2.2.dist-info/licenses/LICENSE,sha256=wbYsm5Ofe8cnxHgWSnSG1vUJDNiY1DIeTyxHSbo1HqM,1066
+pythonclaw-0.2.2.dist-info/METADATA,sha256=shmBvIvx1M7_1_oG8qpMX4Uh-G3YU2PNPRZXtNrzdDU,14586
+pythonclaw-0.2.2.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+pythonclaw-0.2.2.dist-info/entry_points.txt,sha256=4uGCuBw-id_22IRdkoxPVOOcwgiPX5lNEpD1XKQWE4I,52
+pythonclaw-0.2.2.dist-info/top_level.txt,sha256=S_lM2VH3gP3UeZbSWHXIrBOCNtoqn5pk491IAzgsV7M,11
+pythonclaw-0.2.2.dist-info/RECORD,,