dulus 3.9.0__tar.gz → 3.9.1__tar.gz

{dulus-3.9.0/dulus.egg-info → dulus-3.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dulus
-Version: 3.9.0
+Version: 3.9.1
 Summary: Use IA as an agent without an API key. $0. Harvest your browser session for Gemini (guest, no login), Claude.ai, Claude Code, Kimi.com, Qwen, DeepSeek — drive them like an API, no per-token billing. Plus LiteLLM (100+ paid providers), local models via Ollama, /lang in 34 languages, Mesa Redonda, voice, OCR, MemPalace, embedded sandbox OS.
 Author: KevRojo
 License: GPL-3.0
@@ -134,6 +134,8 @@ SET /sticky_input ON since the first run for the best experience!
 
 > Full changelog: [`docs/news.md`](docs/news.md)  ·  Inside the REPL: `/news`
 
+- **🔄 Self-update — the fleet moves as one.** Dulus now keeps itself current: a quiet, cached, non-blocking check against PyPI at startup, and if there's a newer release it upgrades in place. `/update`, `/update now`, `/update status`, `/update on|off`. On by default (the organism heals fastest when every node runs the latest), handles PEP 668, and never blocks your boot. 🦅
+
 - **🔌 MCP Marketplace — 2000+ servers, zero friction.** MCP was always powerful but nobody used it — too much friction: find a server, dig up its launch command, hand-edit JSON, hope it connects. Now: `/mcp search <anything>` browses **2000+ servers** (official [modelcontextprotocol.io](https://registry.modelcontextprotocol.io) registry + the awesome-mcp list, cached & offline-safe), and `/mcp install <name>` installs *and auto-connects* in one shot — tools go live in the same session. Plus a Windows fix so node servers (`npx`) actually launch. From "never touched MCP" to "connected in 5 seconds." 🦅
 
 - **🌍 dulus.work — THE HUB. The secret is out.** This is what Kevin had been hiding (even from Dulus itself 😂): **a global hub where every Dulus instance on the planet shares what it learns.** Your Dulus finds a fix, polishes a skill, adapts a plugin → it can publish it to the hub → every other Dulus in the world can pull it down. Not an update server — an **organism**. Every installation is a node. *The fix a Dulus in Tokyo finds at 3AM, the one in Santo Domingo has by sunrise.* Other agents have N devs improving one product (linear). Dulus makes every user a dev (exponential). The pieces have been quietly shipping for months — SelfImprove engine, Auto-Adapter, the skills format, cloudsave — and now they converge. Domain is live, execution underway. 🦅🇩🇴 → [dulus.work](https://dulus.work)

{dulus-3.9.0 → dulus-3.9.1}/README.md

@@ -68,6 +68,8 @@ SET /sticky_input ON since the first run for the best experience!
 
 > Full changelog: [`docs/news.md`](docs/news.md)  ·  Inside the REPL: `/news`
 
+- **🔄 Self-update — the fleet moves as one.** Dulus now keeps itself current: a quiet, cached, non-blocking check against PyPI at startup, and if there's a newer release it upgrades in place. `/update`, `/update now`, `/update status`, `/update on|off`. On by default (the organism heals fastest when every node runs the latest), handles PEP 668, and never blocks your boot. 🦅
+
 - **🔌 MCP Marketplace — 2000+ servers, zero friction.** MCP was always powerful but nobody used it — too much friction: find a server, dig up its launch command, hand-edit JSON, hope it connects. Now: `/mcp search <anything>` browses **2000+ servers** (official [modelcontextprotocol.io](https://registry.modelcontextprotocol.io) registry + the awesome-mcp list, cached & offline-safe), and `/mcp install <name>` installs *and auto-connects* in one shot — tools go live in the same session. Plus a Windows fix so node servers (`npx`) actually launch. From "never touched MCP" to "connected in 5 seconds." 🦅
 
 - **🌍 dulus.work — THE HUB. The secret is out.** This is what Kevin had been hiding (even from Dulus itself 😂): **a global hub where every Dulus instance on the planet shares what it learns.** Your Dulus finds a fix, polishes a skill, adapts a plugin → it can publish it to the hub → every other Dulus in the world can pull it down. Not an update server — an **organism**. Every installation is a node. *The fix a Dulus in Tokyo finds at 3AM, the one in Santo Domingo has by sunrise.* Other agents have N devs improving one product (linear). Dulus makes every user a dev (exponential). The pieces have been quietly shipping for months — SelfImprove engine, Auto-Adapter, the skills format, cloudsave — and now they converge. Domain is live, execution underway. 🦅🇩🇴 → [dulus.work](https://dulus.work)

{dulus-3.9.0 → dulus-3.9.1}/docs/news.md

@@ -2,6 +2,8 @@
  
 ## 🔥🔥🔥 News (Pacific Time)
 
+- July 11, 2026: **🔄 Self-update — every Dulus stays on the latest, automatically.** The whole point of the organism is that a fix found by one Dulus reaches every other Dulus fast. So now Dulus keeps *itself* current: on startup it does a quiet, cached (6h TTL), non-blocking check against PyPI, and if there's a newer release it upgrades in place — no `pip install -U` dance, no stale nodes drifting behind. New `/update` command with everything you'd expect: `/update` (check + upgrade if newer), `/update now` (force), `/update check` (look but don't touch), `/update status` (see installed vs latest), and `/update on|off` to toggle the automatic startup check (on by default). Handles PEP 668 externally-managed Pythons automatically, and the check *never* blocks or crashes your boot — if PyPI is down or you're offline, Dulus just carries on. The fleet moves as one. 🦅🇩🇴
+
 - July 11, 2026: **🔌 MCP Marketplace — 2000+ servers, zero friction, install by name.** MCP (Model Context Protocol) was always one of Dulus's most powerful features and almost nobody used it — the friction killed it. You had to *find* a server somewhere, dig up its exact launch command, hand-edit a `.mcp.json`, and pray it connected. Dead on arrival. So we built a real marketplace on top of it. `/mcp list` and `/mcp search <anything>` now browse a live catalog of **2000+ servers** pulled from the official [registry.modelcontextprotocol.io](https://registry.modelcontextprotocol.io) (the metaregistry backed by Anthropic, GitHub, Microsoft & PulseMCP) plus the community awesome-mcp list — deduped, cached with a 6h TTL, and **offline-safe** (falls back to a curated set if you're on a plane). Then `/mcp install <name>` does the whole thing in one shot: resolves the launch command, writes the config, **connects, verifies the tools, and hot-reloads them live into your current session** — no restart, no JSON, no manual anything. `/mcp installed` shows what's live with a green/red status dot, `/mcp runtimes` tells you which runtimes (node/python/docker) you've got. Also shipped a Windows launcher fix so node-based servers (`npx`, which ships as `npx.cmd` on Windows) actually start instead of silently failing — probably the real reason MCP "never worked" for a lot of Windows users. From *"I've never touched MCP"* to *"connected in 5 seconds."* 🦅🇩🇴
 
 - July 10, 2026: **🎙️ Dulus has his own voice — Deepgram lands as a first-class voice provider.** Voice on Dulus just leveled up: **Deepgram nova-3** is now the default STT backend the moment a key exists — ~300ms cloud transcription with native keyterm boosting, so your coding vocabulary (`grep`, `MemPalace`, `TypeScript`) comes out spelled right instead of whatever Whisper hallucinates on a noisy mic. And on the speaking side, **Aura-2** joins the TTS chain as the `deepgram` provider with natural per-language voices (`aura-2-celeste-es` for Spanish, `aura-2-thalia-en` for English). Zero SDK, zero heavy model downloads — both talk plain HTTPS, which means voice finally works great on laptops that can't afford a 1GB local Whisper model warming up for 30 seconds. Getting in is stupid simple: create a free account at [deepgram.com](https://deepgram.com) (**$200 in credit, no credit card** — that's roughly 775 hours of transcription), drop the key in `DEEPGRAM_API_KEY` or `deepgram_api_key` in your config, and `/voice`, `/wake` and `/say` are instantly running on it. No key? Nothing changes — local Whisper keeps working as always, and `DULUS_WAKE_FORCE_LOCAL=1` brings it back anytime. The eagle speaks now. 🦅🇩🇴

{dulus-3.9.0 → dulus-3.9.1/dulus.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dulus
-Version: 3.9.0
+Version: 3.9.1
 Summary: Use IA as an agent without an API key. $0. Harvest your browser session for Gemini (guest, no login), Claude.ai, Claude Code, Kimi.com, Qwen, DeepSeek — drive them like an API, no per-token billing. Plus LiteLLM (100+ paid providers), local models via Ollama, /lang in 34 languages, Mesa Redonda, voice, OCR, MemPalace, embedded sandbox OS.
 Author: KevRojo
 License: GPL-3.0
@@ -134,6 +134,8 @@ SET /sticky_input ON since the first run for the best experience!
 
 > Full changelog: [`docs/news.md`](docs/news.md)  ·  Inside the REPL: `/news`
 
+- **🔄 Self-update — the fleet moves as one.** Dulus now keeps itself current: a quiet, cached, non-blocking check against PyPI at startup, and if there's a newer release it upgrades in place. `/update`, `/update now`, `/update status`, `/update on|off`. On by default (the organism heals fastest when every node runs the latest), handles PEP 668, and never blocks your boot. 🦅
+
 - **🔌 MCP Marketplace — 2000+ servers, zero friction.** MCP was always powerful but nobody used it — too much friction: find a server, dig up its launch command, hand-edit JSON, hope it connects. Now: `/mcp search <anything>` browses **2000+ servers** (official [modelcontextprotocol.io](https://registry.modelcontextprotocol.io) registry + the awesome-mcp list, cached & offline-safe), and `/mcp install <name>` installs *and auto-connects* in one shot — tools go live in the same session. Plus a Windows fix so node servers (`npx`) actually launch. From "never touched MCP" to "connected in 5 seconds." 🦅
 
 - **🌍 dulus.work — THE HUB. The secret is out.** This is what Kevin had been hiding (even from Dulus itself 😂): **a global hub where every Dulus instance on the planet shares what it learns.** Your Dulus finds a fix, polishes a skill, adapts a plugin → it can publish it to the hub → every other Dulus in the world can pull it down. Not an update server — an **organism**. Every installation is a node. *The fix a Dulus in Tokyo finds at 3AM, the one in Santo Domingo has by sunrise.* Other agents have N devs improving one product (linear). Dulus makes every user a dev (exponential). The pieces have been quietly shipping for months — SelfImprove engine, Auto-Adapter, the skills format, cloudsave — and now they converge. Domain is live, execution underway. 🦅🇩🇴 → [dulus.work](https://dulus.work)

{dulus-3.9.0 → dulus-3.9.1}/dulus.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ tmux_offloader.py
 tmux_tools.py
 tool_registry.py
 tools.py
+updater.py
 webchat.py
 webchat_server.py
 welcome.py

{dulus-3.9.0 → dulus-3.9.1}/dulus.egg-info/top_level.txt

@@ -42,6 +42,7 @@ tmux_tools
 tool_registry
 tools
 ui
+updater
 voice
 webbridge
 webchat

{dulus-3.9.0 → dulus-3.9.1}/dulus.py

@@ -82,6 +82,10 @@ Slash commands in REPL:
   /plugin enable/disable name  Toggle plugin
   /plugin update name        Update a plugin
   /plugin recommend [ctx]    Recommend plugins for context
+  /update           Check PyPI and update Dulus if a newer version exists
+  /update now       Force update to the latest release
+  /update on|off    Toggle the automatic update check at startup (default: on)
+  /update status    Show installed version, latest, and auto-check setting
   /tasks            List all tasks
   /tasks create <subject>    Quick-create a task
   /tasks start/done/cancel <id>  Update task status
@@ -8486,6 +8490,89 @@ def cmd_profile(args: str, state, config) -> bool:
     return True
 
 
+def cmd_update(args: str, state, config) -> bool:
+    """Self-update Dulus from PyPI — keep every node on the latest release.
+
+    /update            — check PyPI and update now if a newer version exists
+    /update now        — force an update to the latest release
+    /update check      — just check, don't install
+    /update on         — enable the automatic startup check (default)
+    /update off        — disable the automatic startup check
+    /update status     — show current version, latest, and the auto-check setting
+    """
+    try:
+        import updater
+    except Exception as e:
+        err(f"Updater unavailable: {e}")
+        return True
+
+    sub = (args or "").strip().lower()
+
+    # Toggle the automatic startup check
+    if sub in ("on", "enable"):
+        config["auto_update"] = True
+        try:
+            from config import save_config
+            save_config(config)
+        except Exception:
+            pass
+        ok("Automatic update check enabled — Dulus will check PyPI at startup.")
+        return True
+    if sub in ("off", "disable"):
+        config["auto_update"] = False
+        try:
+            from config import save_config
+            save_config(config)
+        except Exception:
+            pass
+        info("Automatic update check disabled. Run /update anytime to check manually.")
+        return True
+
+    if sub == "status":
+        current = updater.get_installed_version()
+        latest = updater.get_latest_version() or "(unreachable)"
+        auto = config.get("auto_update", True)
+        info(f"Installed: {current}")
+        info(f"Latest on PyPI: {latest}")
+        info(f"Auto-check at startup: {'ON' if auto else 'OFF'}")
+        return True
+
+    if sub == "check":
+        available, current, latest = updater.is_update_available()
+        if not latest:
+            info(f"Couldn't reach PyPI. Installed: {current}")
+        elif available:
+            ok(f"Update available: {current} -> {latest}.  Run /update now")
+        else:
+            ok(f"You're on the latest Dulus ({current}). 🦅")
+        return True
+
+    # Default (no arg) and "now" → check + install if newer
+    available, current, latest = updater.is_update_available()
+    if sub != "now":
+        if not latest:
+            info(f"Couldn't reach PyPI. Installed: {current}")
+            return True
+        if not available:
+            ok(f"You're already on the latest Dulus ({current}). 🦅")
+            return True
+        info(f"Updating {current} -> {latest} ...")
+
+    # Perform the upgrade (force for "now", or when an update is available)
+    target = latest if latest else None
+    if sub == "now" and not available and latest and current == latest:
+        ok(f"Already on {current}. Nothing to do.")
+        return True
+    print("  ⏳ Running pip install --upgrade dulus ...")
+    success, message = updater.perform_update(target if available else None)
+    if success:
+        ok(message)
+        info("Restart Dulus to run the new version.")
+    else:
+        err(message)
+    return True
+
+
 def cmd_news(args: str, state, config) -> bool:
     """Show the latest news from docs/news.md."""
     news_file = Path(__file__).parent / "docs" / "news.md"
@@ -9784,6 +9871,9 @@ COMMANDS = {
     "exit":        cmd_exit,
     "quit":        cmd_exit,
     "resume":      cmd_resume,
+    "update":      cmd_update,
+    "upgrade":     cmd_update,
+    "selfupdate":  cmd_update,
     "news":        cmd_news,
     "batch":       cmd_batch,
     "claude_batch": cmd_claude_batch,
@@ -10352,6 +10442,34 @@ def repl(config: dict, initial_prompt: str = None):
             except Exception:
                 pass
 
+        # ── Auto-update check (on by default; /update off to disable) ─────────
+        # Keep every Dulus in the world on the latest release: the organism
+        # heals fastest when fixes propagate instantly. This is intentionally
+        # quiet & fast — cached PyPI check (6h TTL), short timeout, never blocks
+        # or crashes the boot. Set auto_update=False (or /update off) to skip.
+        if config.get("auto_update", True):
+            try:
+                import updater as _updater
+                _avail, _cur, _latest = _updater.is_update_available()
+                if _avail:
+                    print()
+                    info(f"  🆕 A new Dulus is available: {_cur} → {_latest}")
+                    if config.get("auto_update_install", True):
+                        # Kevin's call: force the update at startup so we keep
+                        # the whole fleet in sync. Set auto_update_install=False
+                        # to only notify instead of installing.
+                        print("  ⏳ Updating automatically...")
+                        _ok, _msg = _updater.perform_update(_latest)
+                        if _ok:
+                            ok(f"  {_msg}  Restart to run {_latest}.")
+                        else:
+                            info(f"  Auto-update skipped: {_msg}")
+                            info("  Run /update now to try manually.")
+                    else:
+                        info("  Run /update now to upgrade.")
+            except Exception:
+                pass  # never let the update check break the boot
+
         # First-run /harvest — wizard sets `pending_first_run_harvest` to
         # the provider name the user picked (claude / kimi / gemini / qwen /
         # deepseek). We auto-fire the matching command so they actually

{dulus-3.9.0 → dulus-3.9.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dulus"
-version = "3.9.0"
+version = "3.9.1"
 description = "Use IA as an agent without an API key. $0. Harvest your browser session for Gemini (guest, no login), Claude.ai, Claude Code, Kimi.com, Qwen, DeepSeek — drive them like an API, no per-token billing. Plus LiteLLM (100+ paid providers), local models via Ollama, /lang in 34 languages, Mesa Redonda, voice, OCR, MemPalace, embedded sandbox OS."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -127,6 +127,7 @@ py-modules = [
     "tmux_tools",
     "tool_registry",
     "tools",
+    "updater",
     "webchat",
     "webchat_server",
     "welcome",

dulus-3.9.1/updater.py

@@ -0,0 +1,178 @@
+"""Dulus self-update — keep every Dulus in the world on the latest release.
+
+The organism heals fastest when every node runs the newest code. This module
+checks PyPI for a newer `dulus` release and (optionally) upgrades in place.
+
+Design goals:
+  - Zero friction: on by default, checks quietly at startup.
+  - Fast & non-blocking: PyPI JSON API with a short timeout + local cache so we
+    never hammer the network or slow the boot.
+  - Safe: never crashes the CLI if offline / PyPI is down / pip is weird.
+  - Respectful: a single config flag (`auto_update`) turns it off; a cache TTL
+    avoids checking on every single launch.
+
+Public API:
+    get_installed_version() -> str
+    get_latest_version(timeout=4, use_cache=True) -> str | None
+    is_update_available() -> tuple[bool, str, str]   # (available, current, latest)
+    perform_update(target=None) -> tuple[bool, str]  # (ok, message)
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import time
+import urllib.request
+from pathlib import Path
+
+PYPI_JSON_URL = "https://pypi.org/pypi/dulus/json"
+_CACHE_FILE = Path.home() / ".dulus" / "cache" / "update-check.json"
+_CACHE_TTL_SEC = 6 * 3600  # only hit PyPI at most every 6h for the auto-check
+
+
+# ── Version helpers ─────────────────────────────────────────────────────────
+
+def get_installed_version() -> str:
+    """Return the installed dulus version, or '0.0.0' if undeterminable."""
+    try:
+        from importlib.metadata import version
+        return version("dulus")
+    except Exception:
+        # Running from source without an install — try pyproject as a fallback.
+        try:
+            here = Path(__file__).parent / "pyproject.toml"
+            for line in here.read_text(encoding="utf-8").splitlines():
+                if line.strip().startswith("version"):
+                    return line.split("=")[1].strip().strip('"').strip("'")
+        except Exception:
+            pass
+    return "0.0.0"
+
+
+def _parse(v: str) -> tuple:
+    """Turn '3.9.0' into a comparable tuple (3, 9, 0). Non-numeric parts -> 0."""
+    out = []
+    for part in str(v).split("."):
+        num = "".join(ch for ch in part if ch.isdigit())
+        out.append(int(num) if num else 0)
+    return tuple(out)
+
+
+def _is_newer(latest: str, current: str) -> bool:
+    return _parse(latest) > _parse(current)
+
+
+# ── PyPI query (cached) ─────────────────────────────────────────────────────
+
+def _read_cache() -> dict | None:
+    try:
+        data = json.loads(_CACHE_FILE.read_text(encoding="utf-8"))
+        if time.time() - float(data.get("fetched_at", 0)) < _CACHE_TTL_SEC:
+            return data
+    except Exception:
+        pass
+    return None
+
+
+def _write_cache(latest: str) -> None:
+    try:
+        _CACHE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        _CACHE_FILE.write_text(
+            json.dumps({"fetched_at": time.time(), "latest": latest}),
+            encoding="utf-8",
+        )
+    except Exception:
+        pass
+
+
+def get_latest_version(timeout: int = 4, use_cache: bool = True) -> str | None:
+    """Return the newest dulus version on PyPI, or None if unreachable."""
+    if use_cache:
+        cached = _read_cache()
+        if cached and cached.get("latest"):
+            return cached["latest"]
+
+    # truststore first so we work behind corporate TLS-intercepting proxies
+    try:
+        import truststore
+        truststore.inject_into_ssl()
+    except Exception:
+        pass
+
+    try:
+        req = urllib.request.Request(
+            PYPI_JSON_URL, headers={"User-Agent": "Dulus-Updater/1.0"}
+        )
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            payload = json.loads(resp.read())
+        latest = payload.get("info", {}).get("version")
+        if latest:
+            _write_cache(latest)
+            return latest
+    except Exception:
+        return None
+    return None
+
+
+def is_update_available() -> tuple[bool, str, str]:
+    """Return (update_available, current_version, latest_version_or_empty)."""
+    current = get_installed_version()
+    latest = get_latest_version()
+    if not latest:
+        return (False, current, "")
+    return (_is_newer(latest, current), current, latest)
+
+
+# ── Perform the upgrade ─────────────────────────────────────────────────────
+
+def perform_update(target: str | None = None) -> tuple[bool, str]:
+    """pip-install --upgrade dulus (optionally pinning a specific version).
+
+    Returns (ok, message). Never raises.
+    """
+    pkg = f"dulus=={target}" if target else "dulus"
+    # --upgrade to move forward; PEP 668 environments need --break-system-packages
+    # but only add it as a fallback so we don't clobber managed installs on the
+    # first, cleaner attempt.
+    base = [sys.executable, "-m", "pip", "install", "--upgrade", "--quiet", pkg]
+    try:
+        proc = subprocess.run(base, capture_output=True, text=True, timeout=300)
+        if proc.returncode == 0:
+            # bust the cache so the next check reflects reality
+            try:
+                _CACHE_FILE.unlink(missing_ok=True)
+            except Exception:
+                pass
+            return (True, f"Updated to the latest dulus ({target or 'latest'}).")
+        # Retry once for externally-managed (PEP 668) Pythons.
+        if "externally-managed" in (proc.stderr or "") or "break-system-packages" in (proc.stderr or ""):
+            proc2 = subprocess.run(
+                base + ["--break-system-packages"],
+                capture_output=True, text=True, timeout=300,
+            )
+            if proc2.returncode == 0:
+                try:
+                    _CACHE_FILE.unlink(missing_ok=True)
+                except Exception:
+                    pass
+                return (True, "Updated (PEP 668 override).")
+            return (False, f"pip failed: {(proc2.stderr or proc2.stdout or '').strip()[:300]}")
+        return (False, f"pip failed: {(proc.stderr or proc.stdout or '').strip()[:300]}")
+    except subprocess.TimeoutExpired:
+        return (False, "Update timed out after 5 minutes.")
+    except Exception as e:
+        return (False, f"Update error: {e}")
+
+
+def startup_check_line() -> str | None:
+    """Cheap check used at REPL boot. Returns a one-line notice or None.
+
+    Uses the cache aggressively so startup stays fast. Returns None when
+    up-to-date, offline, or the check is skipped.
+    """
+    available, current, latest = is_update_available()
+    if available:
+        return f"A new Dulus is available: {current} -> {latest}.  Run /update now  (auto: /update on)"
+    return None