dulus 3.10.76__tar.gz → 3.10.78__tar.gz

{dulus-3.10.76/dulus.egg-info → dulus-3.10.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dulus
-Version: 3.10.76
+Version: 3.10.78
 Summary: Provider-independent agent runtime for the terminal — cloud and local models, real tools, MCP, plugins, memory, sub-agents, and Dulus OS.
 Author: KevRojo
 License: GPL-3.0-only
@@ -254,6 +254,14 @@ iwr -useb https://raw.githubusercontent.com/KevRojo/Dulus/main/install.ps1 | iex
 
 Windows users who do not want Python or a terminal can download the self-contained MSI from [GitHub Releases](https://github.com/KevRojo/Dulus/releases).
 
+### Dulus for Windows — desktop app (alpha/beta trial)
+
+The full **Dulus desktop app** for Windows is now in open trial. No Python, no terminal, no API key — download, install, sign in, and go.
+
+**[⬇️ Dulus Windows Trial setup (alpha/beta)](https://drive.google.com/file/d/1Nxz_coVpXRwKQB7baI_0nG12-p1cLznZ/view)**
+
+It is early — expect rough edges, and tell us about them in [Issues](https://github.com/KevRojo/Dulus/issues). The CLI in this repository stays free and open source; the desktop app is the same engine with a face.
+
 ### Docker
 
 ```bash

{dulus-3.10.76 → dulus-3.10.78}/README.md

@@ -176,6 +176,14 @@ iwr -useb https://raw.githubusercontent.com/KevRojo/Dulus/main/install.ps1 | iex
 
 Windows users who do not want Python or a terminal can download the self-contained MSI from [GitHub Releases](https://github.com/KevRojo/Dulus/releases).
 
+### Dulus for Windows — desktop app (alpha/beta trial)
+
+The full **Dulus desktop app** for Windows is now in open trial. No Python, no terminal, no API key — download, install, sign in, and go.
+
+**[⬇️ Dulus Windows Trial setup (alpha/beta)](https://drive.google.com/file/d/1Nxz_coVpXRwKQB7baI_0nG12-p1cLznZ/view)**
+
+It is early — expect rough edges, and tell us about them in [Issues](https://github.com/KevRojo/Dulus/issues). The CLI in this repository stays free and open source; the desktop app is the same engine with a face.
+
 ### Docker
 
 ```bash

{dulus-3.10.76 → dulus-3.10.78}/checkpoint/__init__.py

@@ -9,6 +9,7 @@ from .store import (
     files_changed_since,
     delete_session_checkpoints,
     cleanup_old_sessions,
+    enforce_store_budget,
     reset_file_versions,
 )
 from .hooks import (
@@ -22,6 +23,7 @@ __all__ = [
     "FileBackup", "Snapshot", "MAX_SNAPSHOTS",
     "track_file_edit", "make_snapshot", "list_snapshots", "get_snapshot",
     "rewind_files", "files_changed_since",
-    "delete_session_checkpoints", "cleanup_old_sessions", "reset_file_versions",
+    "delete_session_checkpoints", "cleanup_old_sessions", "enforce_store_budget",
+    "reset_file_versions",
     "set_session", "get_tracked_edits", "reset_tracked", "install_hooks",
 ]

{dulus-3.10.76 → dulus-3.10.78}/checkpoint/store.py

@@ -22,6 +22,18 @@ from .types import FileBackup, Snapshot, MAX_SNAPSHOTS
 # Max file size to back up (1 MB)
 _MAX_FILE_SIZE = 1 * 1024 * 1024
 
+# Hard ceiling for the whole checkpoint store. Age-based cleanup alone cannot
+# bound this: MAX_SNAPSHOTS caps snapshots *per session*, but nothing capped
+# the number of sessions, so a busy machine could accumulate gigabytes long
+# before the 30-day cutoff ever applied. Sentry caught exactly that in the
+# wild -- ENOSPC from mkdir under ~/.dulus/checkpoints on a user's server.
+_MAX_STORE_BYTES = 512 * 1024 * 1024
+
+# Free space below which we stop writing new backups entirely. Checkpoints are
+# a convenience feature; they must never be the reason a user's disk fills up
+# or their session dies.
+_MIN_FREE_BYTES = 256 * 1024 * 1024
+
 # Per-file version counters (reset per session)
 _file_versions: dict[str, int] = {}
 
@@ -34,15 +46,29 @@ def _session_dir(session_id: str) -> Path:
     return _checkpoints_root() / session_id
 
 
+def _safe_mkdir(path: Path) -> bool:
+    """mkdir -p that never raises.
+
+    A full disk raised OSError(ENOSPC) straight out of pathlib.mkdir and took
+    the whole session down with it. Checkpointing is optional; failing to
+    create its directory must degrade silently, not crash the caller.
+    """
+    try:
+        path.mkdir(parents=True, exist_ok=True)
+        return True
+    except OSError:
+        return False
+
+
 def _backups_dir(session_id: str) -> Path:
     d = _session_dir(session_id) / "backups"
-    d.mkdir(parents=True, exist_ok=True)
+    _safe_mkdir(d)
     return d
 
 
 def _snapshots_file(session_id: str) -> Path:
     d = _session_dir(session_id)
-    d.mkdir(parents=True, exist_ok=True)
+    _safe_mkdir(d)
     return d / "snapshots.json"
 
 
@@ -51,6 +77,90 @@ def _path_hash(file_path: str) -> str:
     return hashlib.sha256(file_path.encode()).hexdigest()[:16]
 
 
+def _dir_size(path: Path) -> int:
+    """Total bytes under path. Best-effort: unreadable entries are skipped."""
+    total = 0
+    try:
+        for entry in path.rglob("*"):
+            try:
+                if entry.is_file():
+                    total += entry.stat().st_size
+            except OSError:
+                continue
+    except OSError:
+        pass
+    return total
+
+
+def _free_bytes(path: Path) -> int | None:
+    """Free space on the filesystem holding path, or None if undeterminable."""
+    try:
+        return shutil.disk_usage(str(path)).free
+    except OSError:
+        return None
+
+
+def _has_room_for_backups() -> bool:
+    """Whether it is safe to write another backup.
+
+    Returns False when the store has grown past its ceiling or the disk is
+    nearly full. Callers must degrade gracefully: losing a checkpoint is
+    acceptable, killing the user's session with ENOSPC is not.
+    """
+    root = _checkpoints_root()
+    free = _free_bytes(root if root.exists() else root.parent)
+    if free is not None and free < _MIN_FREE_BYTES:
+        return False
+    return _dir_size(root) < _MAX_STORE_BYTES
+
+
+def enforce_store_budget() -> int:
+    """Evict oldest sessions until the store fits in _MAX_STORE_BYTES.
+
+    Age-based cleanup runs on a 30-day cutoff, which is far too slow for a
+    machine that opens many sessions a day. This is the size-based backstop.
+    Returns the number of sessions removed.
+    """
+    root = _checkpoints_root()
+    if not root.exists():
+        return 0
+
+    size = _dir_size(root)
+    free = _free_bytes(root)
+    over_budget = size > _MAX_STORE_BYTES
+    low_disk = free is not None and free < _MIN_FREE_BYTES
+    if not (over_budget or low_disk):
+        return 0
+
+    try:
+        sessions = [d for d in root.iterdir() if d.is_dir()]
+    except OSError:
+        return 0
+
+    # Oldest first, so recent (likely resumable) sessions survive.
+    def _mtime(d: Path) -> float:
+        try:
+            return d.stat().st_mtime
+        except OSError:
+            return 0.0
+
+    sessions.sort(key=_mtime)
+
+    # When the disk itself is tight, free space aggressively rather than
+    # stopping at the store ceiling.
+    target = _MAX_STORE_BYTES // 2 if low_disk else _MAX_STORE_BYTES
+
+    removed = 0
+    for d in sessions:
+        if size <= target:
+            break
+        freed = _dir_size(d)
+        shutil.rmtree(str(d), ignore_errors=True)
+        size -= freed
+        removed += 1
+    return removed
+
+
 def _next_version(file_path: str) -> int:
     v = _file_versions.get(file_path, 0) + 1
     _file_versions[file_path] = v
@@ -72,9 +182,14 @@ def _load_snapshots(session_id: str) -> list[Snapshot]:
 
 def _save_snapshots(session_id: str, snapshots: list[Snapshot]) -> None:
     f = _snapshots_file(session_id)
-    f.parent.mkdir(parents=True, exist_ok=True)
+    if not _safe_mkdir(f.parent):
+        return
     data = [s.to_dict() for s in snapshots]
-    f.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+    try:
+        f.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
+    except OSError as e:
+        # ENOSPC and friends: drop the checkpoint rather than the session.
+        print(f"[checkpoint] could not persist snapshots: {e}")
 
 
 # ── Public API ───────────────────────────────────────────────────────────────
@@ -100,6 +215,12 @@ def track_file_edit(session_id: str, file_path: str) -> str | None:
         print(f"[checkpoint] skipping large file ({size} bytes): {file_path}")
         return None
 
+    # Disk guard: never let a convenience feature fill the user's disk.
+    if not _has_room_for_backups():
+        enforce_store_budget()
+        if not _has_room_for_backups():
+            return None
+
     # Copy file to backups/
     version = _next_version(file_path)
     backup_name = f"{_path_hash(file_path)}@v{version}"

{dulus-3.10.76 → dulus-3.10.78}/docs/news.md

@@ -2,6 +2,10 @@
  
 ## 🔥🔥🔥 News (Pacific Time)
 
+- August 14, 2026 (**v3.10.78**): **🩹 Checkpoints can no longer fill your disk.** The checkpoint store only pruned sessions older than 30 days, so a machine that opens many sessions a day could run out of space long before that cutoff applied — and when the disk filled, the resulting `ENOSPC` escaped and took the session down with it. There is now a hard 512 MB ceiling on the store plus a free-space floor: oldest sessions are evicted first, backups are skipped when space is tight, and a full disk degrades to "no checkpoint" instead of an error. Reported from the wild via crash telemetry. 🦅🇩🇴
+
+- August 14, 2026 (**v3.10.77**): **🖥️ The Dulus desktop app for Windows is out in open trial (alpha/beta).** Same engine you've been running in the terminal — now with a face. No Python, no terminal, no API key: download, install, sign in, go. **[⬇️ Dulus Windows Trial setup (alpha/beta)](https://drive.google.com/file/d/1Nxz_coVpXRwKQB7baI_0nG12-p1cLznZ/view)**. It is early and it will have rough edges — that's the point of a trial, so [file what breaks](https://github.com/KevRojo/Dulus/issues). The CLI in this repo stays free and open source, forever. 🦅🇩🇴
+
 - August 13, 2026 (**v3.10.76**): **⌨️ Quick menu moved to `↓↓`.** It used to open on double-tap `←←` — which happens to be the exact key you press to go back and fix one word, so editing a typo kept ambushing you with a menu. Now it's **double-tap Down (`↓↓`)**; a single `↓` still just moves down / walks history. Fewer accidental menus, same fast effort/thinking/model switcher. `pip install --upgrade dulus`. 🦅🇩🇴
 
 - August 9, 2026 (**v3.10.75**): **⚡ `/mcp search` got instant too + smarter tool use.** MCP server search now hits our own **Algolia index** (~3k servers) before the slow live registry crawl — **~1ms, typo-tolerant** instead of 10s+. And Dulus now chains tools far more aggressively: independent calls fire in parallel, multi-step file hunts run in **one Python-kernel sweep** (`os.walk` + regex) instead of a dozen Grep/Read round-trips — fewer tokens, faster answers. `DULUS_ALGOLIA=0` opts out of Algolia. `pip install --upgrade dulus`. 🦅🇩🇴

{dulus-3.10.76 → dulus-3.10.78/dulus.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dulus
-Version: 3.10.76
+Version: 3.10.78
 Summary: Provider-independent agent runtime for the terminal — cloud and local models, real tools, MCP, plugins, memory, sub-agents, and Dulus OS.
 Author: KevRojo
 License: GPL-3.0-only
@@ -254,6 +254,14 @@ iwr -useb https://raw.githubusercontent.com/KevRojo/Dulus/main/install.ps1 | iex
 
 Windows users who do not want Python or a terminal can download the self-contained MSI from [GitHub Releases](https://github.com/KevRojo/Dulus/releases).
 
+### Dulus for Windows — desktop app (alpha/beta trial)
+
+The full **Dulus desktop app** for Windows is now in open trial. No Python, no terminal, no API key — download, install, sign in, and go.
+
+**[⬇️ Dulus Windows Trial setup (alpha/beta)](https://drive.google.com/file/d/1Nxz_coVpXRwKQB7baI_0nG12-p1cLznZ/view)**
+
+It is early — expect rough edges, and tell us about them in [Issues](https://github.com/KevRojo/Dulus/issues). The CLI in this repository stays free and open source; the desktop app is the same engine with a face.
+
 ### Docker
 
 ```bash

{dulus-3.10.76 → dulus-3.10.78}/dulus.py

@@ -380,7 +380,7 @@ try:
     from importlib.metadata import version as _pkg_version
     VERSION = _pkg_version("dulus")
 except Exception:
-    VERSION = "3.10.76"  # dev fallback — keep in sync with pyproject.toml
+    VERSION = "3.10.78"  # dev fallback — keep in sync with pyproject.toml
 
 # ── ANSI helpers (used even with rich for non-markdown output) ─────────────
 from common import C, clr, info, ok, warn, err, stream_thinking, sanitize_text
@@ -10669,15 +10669,21 @@ def cmd_claude_batch(args: str, _state, config) -> bool:
 def cmd_buy_dulus(_args: str, _state, _config) -> bool:
     """Open the $DULUS DexScreener page. Temporary / undocumented — not in /help."""
     url = "https://tinyurl.com/DulusDexScreener"
+    trial_url = "https://drive.google.com/file/d/1Nxz_coVpXRwKQB7baI_0nG12-p1cLznZ/view"
     try:
         from cli_animations.ansi import gradient_text, ORANGE, CYAN
         styled = gradient_text(url, ORANGE, CYAN)
+        styled_trial = gradient_text(trial_url, ORANGE, CYAN)
     except Exception:
         styled = url
+        styled_trial = trial_url
     print()
     print(clr("  buy $dulus", "bold"))
     print(f"  {styled}")
     print()
+    print(clr("  Dulus Windows Trial setup (alpha/beta)", "bold"))
+    print(f"  {styled_trial}")
+    print()
     try:
         import webbrowser
         webbrowser.open(url)
@@ -11558,6 +11564,14 @@ def repl(config: dict, initial_prompt: str | None = None):
 
     ckpt.set_session(session_id)
     ckpt.cleanup_old_sessions()
+    # Age-based cleanup only evicts sessions older than 30 days, which is far
+    # too slow for a machine that opens many sessions a day. Enforce the size
+    # ceiling too, otherwise the store grows until the disk runs out (observed
+    # in the wild: ENOSPC under ~/.dulus/checkpoints on a user's server).
+    try:
+        ckpt.enforce_store_budget()
+    except Exception:
+        pass
     # Initial snapshot: capture the "blank slate" before any prompts
     ckpt.make_snapshot(session_id, state, config, "(initial state)", tracked_edits=None)
 

{dulus-3.10.76 → dulus-3.10.78}/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dulus"
-version = "3.10.76"
+version = "3.10.78"
 description = "Provider-independent agent runtime for the terminal — cloud and local models, real tools, MCP, plugins, memory, sub-agents, and Dulus OS."
 readme = "README.md"
 requires-python = ">=3.10"

{dulus-3.10.76 → dulus-3.10.78}/tests/test_checkpoint.py

@@ -456,3 +456,78 @@ class TestIntegration:
         state.turn_count = snap1.turn_count
         assert len(state.messages) == 0
         assert state.turn_count == 0
+
+
+class TestDiskBudget:
+    """Regression tests for the ENOSPC incident.
+
+    A user's server filled its disk and pathlib.mkdir raised OSError straight
+    out of the checkpoint store, killing the session. Age-based cleanup could
+    not have prevented it: MAX_SNAPSHOTS bounds snapshots per session, but
+    nothing bounded the number of sessions before the 30-day cutoff applied.
+    """
+
+    def test_enforce_store_budget_evicts_oldest_first(self, tmp_home):
+        import time as _time
+        from checkpoint import store
+
+        _tmp, ckpt_root = tmp_home
+        for name in ("old", "mid", "new"):
+            d = ckpt_root / name
+            (d / "backups").mkdir(parents=True)
+            (d / "backups" / "blob").write_bytes(b"x" * 4096)
+
+        now = _time.time()
+        os.utime(ckpt_root / "old", (now - 9000, now - 9000))
+        os.utime(ckpt_root / "mid", (now - 6000, now - 6000))
+        os.utime(ckpt_root / "new", (now - 10, now - 10))
+
+        # Force the store over budget so eviction has to run.
+        with patch.object(store, "_MAX_STORE_BYTES", 6000):
+            removed = store.enforce_store_budget()
+
+        assert removed >= 1
+        # Newest session must survive; oldest must be the first to go.
+        assert (ckpt_root / "new").exists()
+        assert not (ckpt_root / "old").exists()
+
+    def test_enforce_store_budget_noop_when_under_budget(self, tmp_home):
+        from checkpoint import store
+
+        _tmp, ckpt_root = tmp_home
+        d = ckpt_root / "session-a"
+        (d / "backups").mkdir(parents=True)
+        (d / "backups" / "blob").write_bytes(b"x" * 128)
+
+        assert store.enforce_store_budget() == 0
+        assert d.exists()
+
+    def test_track_file_edit_skips_when_disk_is_full(self, tmp_home, tmp_path):
+        """No backup should be written when the disk is nearly full."""
+        from checkpoint import store
+
+        target = tmp_path / "code.py"
+        target.write_text("print('hi')", encoding="utf-8")
+
+        with patch.object(store, "_has_room_for_backups", return_value=False):
+            result = store.track_file_edit("session-full", str(target))
+
+        assert result is None
+
+    def test_safe_mkdir_swallows_enospc(self, tmp_home):
+        """A full disk must not raise out of the checkpoint store."""
+        from checkpoint import store
+
+        with patch.object(
+            Path, "mkdir", side_effect=OSError(28, "No space left on device")
+        ):
+            assert store._safe_mkdir(Path("/whatever/nested")) is False
+
+    def test_save_snapshots_survives_enospc(self, tmp_home):
+        """Persisting snapshots must degrade, not crash, on a full disk."""
+        from checkpoint import store
+
+        with patch.object(
+            Path, "write_text", side_effect=OSError(28, "No space left on device")
+        ):
+            store._save_snapshots("session-x", [])  # must not raise