dulus 3.9.5__tar.gz → 3.10.2__tar.gz

{dulus-3.9.5 → dulus-3.10.2}/MANIFEST.in

@@ -6,5 +6,6 @@ recursive-include gui/dulus_orchestrator/dist *
 exclude gui/dulus_orchestrator/dist/runtime-state.js
 exclude gui/dulus_orchestrator/dist/desktop-pet.html
 recursive-include webbridge *
+recursive-include webchat_ui *.html *.css *.js
 global-exclude __pycache__/*
 global-exclude *.pyc

{dulus-3.9.5/dulus.egg-info → dulus-3.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dulus
-Version: 3.9.5
+Version: 3.10.2
 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

{dulus-3.9.5 → dulus-3.10.2}/agent.py

@@ -162,6 +162,8 @@ def run(
             tool_schemas=get_tool_schemas(),
             config=config,
         )):
+            if cancel_check and cancel_check():
+                return
             if isinstance(event, (TextChunk, ThinkingChunk)):
                 yield event
             elif isinstance(event, AssistantTurn):
@@ -217,6 +219,8 @@ def run(
 
         # ── Execute tools ────────────────────────────────────────────────
         for tc in assistant_turn.tool_calls:
+            if cancel_check and cancel_check():
+                return
             yield ToolStart(tc["name"], tc["input"])
 
             # ── Governance gate (capabilities + pre_tool hook) ───────────────

{dulus-3.9.5 → dulus-3.10.2}/analytics.py

@@ -29,7 +29,6 @@ silently ignored; telemetry must never slow down or break Dulus.
 from __future__ import annotations
 
 import base64
-import datetime as _dt
 import json
 import os
 import platform
@@ -46,23 +45,6 @@ MP_TOKEN = os.environ.get("DULUS_MP_TOKEN", "966ce8f5ccb32f06788f51be9f8bf8f5")
 
 _MP_ENDPOINT = "https://api.mixpanel.com/track"
 
-# ── PostHog (product analytics, runs alongside Mixpanel) ────────────────────
-# Project API keys (phc_...) are public/write-only by design — meant to ship in
-# client code, cannot read data. Override with DULUS_POSTHOG_KEY.
-POSTHOG_KEY = os.environ.get(
-    "DULUS_POSTHOG_KEY", "phc_yqAJ42vbj8YFkdpxZicsS4asdbWFTPy6orR8uRNewfYD"
-)
-_POSTHOG_ENDPOINT = os.environ.get(
-    "DULUS_POSTHOG_HOST", "https://us.i.posthog.com"
-).rstrip("/") + "/capture/"
-
-# ── Amplitude (behavioral analytics, runs alongside the others) ─────────────
-# API keys are write-only client keys (safe to ship). Override w/ DULUS_AMPLITUDE_KEY.
-AMPLITUDE_KEY = os.environ.get(
-    "DULUS_AMPLITUDE_KEY", "2511c9e1fc597b8bc6b81f193cc615a2"
-)
-_AMPLITUDE_ENDPOINT = "https://api2.amplitude.com/2/httpapi"
-
 # Populated by init_telemetry(); None = not initialised / disabled.
 _distinct_id: str | None = None
 _enabled: bool = False
@@ -139,11 +121,10 @@ def track(event: str, properties: dict | None = None) -> None:
     }
 
     def _send() -> None:
-        from urllib.request import Request, urlopen
-        from urllib.parse import urlencode
-
-        # Mixpanel
         try:
+            from urllib.request import Request, urlopen
+            from urllib.parse import urlencode
+
             data = urlencode(
                 {"data": base64.b64encode(json.dumps([payload]).encode()).decode()}
             ).encode()
@@ -152,55 +133,6 @@ def track(event: str, properties: dict | None = None) -> None:
         except Exception:
             pass  # telemetry must never break Dulus
 
-        # PostHog (same event, product-analytics brain)
-        if POSTHOG_KEY:
-            try:
-                ph_props = {
-                    "dulus_version": _dulus_version,
-                    "os": platform.system(),
-                    "python": f"{sys.version_info.major}.{sys.version_info.minor}",
-                    "$process_person_profile": False,  # anonymous, no PII person
-                    **(properties or {}),
-                }
-                ph_payload = {
-                    "api_key": POSTHOG_KEY,
-                    "event": event,
-                    "distinct_id": _distinct_id,
-                    "properties": ph_props,
-                    "timestamp": _dt.datetime.utcnow().isoformat() + "Z",
-                }
-                ph_data = json.dumps(ph_payload).encode()
-                ph_req = Request(
-                    _POSTHOG_ENDPOINT, data=ph_data, method="POST",
-                    headers={"Content-Type": "application/json"},
-                )
-                urlopen(ph_req, timeout=4).read()
-            except Exception:
-                pass  # telemetry must never break Dulus
-
-        # Amplitude (same event, behavioral-analytics brain)
-        if AMPLITUDE_KEY:
-            try:
-                amp_event = {
-                    "user_id": (_distinct_id or "anon").ljust(5, "_"),  # min 5 chars
-                    "event_type": event,
-                    "platform": platform.system(),
-                    "app_version": _dulus_version,
-                    "event_properties": (properties or {}),
-                }
-                amp_payload = {
-                    "api_key": AMPLITUDE_KEY,
-                    "events": [amp_event],
-                }
-                amp_data = json.dumps(amp_payload).encode()
-                amp_req = Request(
-                    _AMPLITUDE_ENDPOINT, data=amp_data, method="POST",
-                    headers={"Content-Type": "application/json"},
-                )
-                urlopen(amp_req, timeout=4).read()
-            except Exception:
-                pass  # telemetry must never break Dulus
-
     threading.Thread(target=_send, daemon=True, name="telemetry").start()
 
 

dulus-3.10.2/display_blocks.py

@@ -0,0 +1,529 @@
+"""Display Blocks System - Visual representations of agent actions.
+
+Provides a structured way to represent agent actions visually across multiple
+frontends: CLI (dulus.py), WebChat (webchat_server.py), and Telegram.
+
+Display blocks are dict-based and can be rendered in various formats.
+"""
+from __future__ import annotations
+
+import difflib
+import html
+from typing import Literal
+
+
+# ── Display block type hints ─────────────────────────────────────────────────
+
+# These are the supported display block types
+DisplayBlockType = Literal[
+    "diff",
+    "todo",
+    "shell",
+    "background_task",
+    "think",
+    "code",
+    "table",
+    "error",
+]
+
+
+# ── CLI Renderer ─────────────────────────────────────────────────────────────
+
+
+class DisplayBlockRenderer:
+    """Render display blocks in various formats for different frontends.
+
+    Supports CLI (terminal), HTML (WebChat), and Telegram (Markdown) output formats.
+    Each render method takes a display block dict and returns a formatted string.
+    """
+
+    # ── Public API ──────────────────────────────────────────────────────────
+
+    @staticmethod
+    def render_cli(block: dict) -> str:
+        """Render a display block for CLI (terminal) output.
+
+        Args:
+            block: Display block dict with at least a 'type' key.
+
+        Returns:
+            Formatted string suitable for terminal display.
+        """
+        block_type = block.get("type", "unknown")
+        renderer = _CLI_RENDERERS.get(block_type, _CLI_RENDERERS["unknown"])
+        return renderer(block)
+
+    @staticmethod
+    def render_html(block: dict) -> str:
+        """Render a display block as HTML for WebChat.
+
+        Args:
+            block: Display block dict with at least a 'type' key.
+
+        Returns:
+            HTML string suitable for web display.
+        """
+        block_type = block.get("type", "unknown")
+        renderer = _HTML_RENDERERS.get(block_type, _HTML_RENDERERS["unknown"])
+        return renderer(block)
+
+    @staticmethod
+    def render_telegram(block: dict) -> str:
+        """Render a display block for Telegram (Markdown V2).
+
+        Args:
+            block: Display block dict with at least a 'type' key.
+
+        Returns:
+            Formatted string using Telegram Markdown V2 syntax.
+        """
+        block_type = block.get("type", "unknown")
+        renderer = _TG_RENDERERS.get(block_type, _TG_RENDERERS["unknown"])
+        return renderer(block)
+
+    @staticmethod
+    def render(block: dict, format: Literal["cli", "html", "telegram"] = "cli") -> str:
+        """Render a display block in the specified format.
+
+        Args:
+            block: Display block dict with at least a 'type' key.
+            format: Target format - "cli", "html", or "telegram".
+
+        Returns:
+            Formatted string in the requested format.
+        """
+        if format == "cli":
+            return DisplayBlockRenderer.render_cli(block)
+        elif format == "html":
+            return DisplayBlockRenderer.render_html(block)
+        elif format == "telegram":
+            return DisplayBlockRenderer.render_telegram(block)
+        return str(block)
+
+
+# ── CLI Renderers ────────────────────────────────────────────────────────────
+
+
+def _render_diff_cli(block: dict) -> str:
+    """Render a diff display block for CLI.
+
+    Shows a unified diff between old and new text.
+    """
+    path = block.get("path", "<unknown>")
+    old_text = block.get("old_text", "")
+    new_text = block.get("new_text", "")
+    old_start = block.get("old_start", 1)
+    new_start = block.get("new_start", 1)
+    is_summary = block.get("is_summary", False)
+
+    if is_summary:
+        return f"[Diff: {path}] (summary)"
+
+    old_lines = old_text.splitlines(keepends=True)
+    new_lines = new_text.splitlines(keepends=True)
+
+    # Generate unified diff
+    diff = difflib.unified_diff(
+        old_lines,
+        new_lines,
+        fromfile=f"a/{path}",
+        tofile=f"b/{path}",
+        lineterm="",
+    )
+    diff_text = "\n".join(diff)
+
+    if not diff_text:
+        return f"[Diff: {path}] No changes"
+
+    return f"[Diff: {path}]\n{diff_text}"
+
+
+def _render_todo_cli(block: dict) -> str:
+    """Render a todo display block for CLI."""
+    items = block.get("items", [])
+    if not items:
+        return "[Todo] No items"
+
+    lines = ["Todo List:"]
+    icons = {"pending": "[ ]", "in_progress": "[/]", "done": "[x]"}
+    for item in items:
+        status = item.get("status", "pending")
+        icon = icons.get(status, "[ ]")
+        lines.append(f"  {icon} {item.get('title', '')}")
+    return "\n".join(lines)
+
+
+def _render_shell_cli(block: dict) -> str:
+    """Render a shell command display block for CLI."""
+    command = block.get("command", "")
+    language = block.get("language", "bash")
+    return f"$ {command}"
+
+
+def _render_bg_task_cli(block: dict) -> str:
+    """Render a background task display block for CLI."""
+    task_id = block.get("task_id", "?")
+    kind = block.get("kind", "?")
+    status = block.get("status", "?")
+    description = block.get("description", "")
+
+    icons = {
+        "running": "●",
+        "completed": "✓",
+        "failed": "✗",
+        "stopped": "■",
+    }
+    icon = icons.get(status, "?")
+    return f"{icon} [{task_id}] {description} ({kind}, {status})"
+
+
+def _render_think_cli(block: dict) -> str:
+    """Render a think display block for CLI."""
+    thought = block.get("thought", "")
+    lines = thought.splitlines()
+    # Indent thought content for visual distinction
+    indented = "\n".join(f"  | {line}" for line in lines)
+    return f"[Thinking...]\n{indented}"
+
+
+def _render_code_cli(block: dict) -> str:
+    """Render a code display block for CLI."""
+    code = block.get("code", "")
+    language = block.get("language", "")
+    header = f"```{language}" if language else "```"
+    return f"{header}\n{code}\n```"
+
+
+def _render_table_cli(block: dict) -> str:
+    """Render a table display block for CLI."""
+    headers = block.get("headers", [])
+    rows = block.get("rows", [])
+    if not headers and not rows:
+        return "[Table] Empty"
+
+    # Simple text table rendering
+    all_rows = [headers] + rows if headers else rows
+    # Calculate column widths
+    col_count = max(len(r) for r in all_rows) if all_rows else 0
+    widths = [0] * col_count
+    for row in all_rows:
+        for i, cell in enumerate(row):
+            widths[i] = max(widths[i], len(str(cell)))
+
+    def _fmt_row(row: list) -> str:
+        cells = [str(cell).ljust(widths[i]) for i, cell in enumerate(row)]
+        return " | ".join(cells)
+
+    lines = []
+    if headers:
+        lines.append(_fmt_row(headers))
+        lines.append("-" * (sum(widths) + 3 * (col_count - 1)))
+    for row in rows:
+        lines.append(_fmt_row(row))
+    return "\n".join(lines)
+
+
+def _render_error_cli(block: dict) -> str:
+    """Render an error display block for CLI."""
+    message = block.get("message", "Unknown error")
+    return f"[Error] {message}"
+
+
+def _render_unknown_cli(block: dict) -> str:
+    """Render an unknown display block type for CLI."""
+    return f"[Display Block: {block.get('type', 'unknown')}]\n{str(block)}"
+
+
+_CLI_RENDERERS: dict[str, callable] = {
+    "diff": _render_diff_cli,
+    "todo": _render_todo_cli,
+    "shell": _render_shell_cli,
+    "background_task": _render_bg_task_cli,
+    "think": _render_think_cli,
+    "code": _render_code_cli,
+    "table": _render_table_cli,
+    "error": _render_error_cli,
+    "unknown": _render_unknown_cli,
+}
+
+
+# ── HTML Renderers ───────────────────────────────────────────────────────────
+
+
+def _render_diff_html(block: dict) -> str:
+    """Render a diff display block as HTML."""
+    path = html.escape(block.get("path", "<unknown>"))
+    old_text = html.escape(block.get("old_text", ""))
+    new_text = html.escape(block.get("new_text", ""))
+
+    return (
+        f'<div class="display-block diff-block">\n'
+        f'  <div class="diff-header">{path}</div>\n'
+        f'  <pre class="diff-old"><code>{old_text}</code></pre>\n'
+        f'  <pre class="diff-new"><code>{new_text}</code></pre>\n'
+        f"</div>"
+    )
+
+
+def _render_todo_html(block: dict) -> str:
+    """Render a todo display block as HTML."""
+    items = block.get("items", [])
+    if not items:
+        return '<div class="display-block todo-block"><p>No items</p></div>'
+
+    lines = ['<div class="display-block todo-block"><ul>']
+    icons = {
+        "pending": "⬜",
+        "in_progress": "🔄",
+        "done": "✅",
+    }
+    for item in items:
+        status = item.get("status", "pending")
+        icon = icons.get(status, "⬜")
+        title = html.escape(item.get("title", ""))
+        css_class = f"todo-{status}"
+        lines.append(f'  <li class="{css_class}">{icon} {title}</li>')
+    lines.append("</ul></div>")
+    return "\n".join(lines)
+
+
+def _render_shell_html(block: dict) -> str:
+    """Render a shell command display block as HTML."""
+    command = html.escape(block.get("command", ""))
+    language = html.escape(block.get("language", "bash"))
+    return (
+        f'<div class="display-block shell-block">\n'
+        f'  <pre><code class="language-{language}">${command}</code></pre>\n'
+        f"</div>"
+    )
+
+
+def _render_bg_task_html(block: dict) -> str:
+    """Render a background task display block as HTML."""
+    task_id = html.escape(block.get("task_id", "?"))
+    kind = html.escape(block.get("kind", "?"))
+    status = html.escape(block.get("status", "?"))
+    description = html.escape(block.get("description", ""))
+
+    status_colors = {
+        "running": "#2196F3",
+        "completed": "#4CAF50",
+        "failed": "#f44336",
+        "stopped": "#FF9800",
+    }
+    color = status_colors.get(status, "#9E9E9E")
+
+    return (
+        f'<div class="display-block bg-task-block">\n'
+        f'  <span class="task-id">[{task_id}]</span>\n'
+        f'  <span class="task-desc">{description}</span>\n'
+        f'  <span class="task-kind">({kind})</span>\n'
+        f'  <span class="task-status" style="color: {color};">{status}</span>\n'
+        f"</div>"
+    )
+
+
+def _render_think_html(block: dict) -> str:
+    """Render a think display block as HTML."""
+    thought = html.escape(block.get("thought", ""))
+    return (
+        f'<div class="display-block think-block">\n'
+        f'  <div class="think-header">💭 Thinking</div>\n'
+        f'  <pre class="think-content">{thought}</pre>\n'
+        f"</div>"
+    )
+
+
+def _render_code_html(block: dict) -> str:
+    """Render a code display block as HTML."""
+    code = html.escape(block.get("code", ""))
+    language = html.escape(block.get("language", ""))
+    return (
+        f'<div class="display-block code-block">\n'
+        f'  <pre><code class="language-{language}">{code}</code></pre>\n'
+        f"</div>"
+    )
+
+
+def _render_table_html(block: dict) -> str:
+    """Render a table display block as HTML."""
+    headers = block.get("headers", [])
+    rows = block.get("rows", [])
+    if not headers and not rows:
+        return '<div class="display-block table-block"><p>Empty table</p></div>'
+
+    lines = ['<div class="display-block table-block">', "<table>"]
+    if headers:
+        lines.append("  <tr>" + "".join(f"<th>{html.escape(str(h))}</th>" for h in headers) + "</tr>")
+    for row in rows:
+        lines.append("  <tr>" + "".join(f"<td>{html.escape(str(c))}</td>" for c in row) + "</tr>")
+    lines.extend(["</table>", "</div>"])
+    return "\n".join(lines)
+
+
+def _render_error_html(block: dict) -> str:
+    """Render an error display block as HTML."""
+    message = html.escape(block.get("message", "Unknown error"))
+    return (
+        f'<div class="display-block error-block" style="color: #f44336;">\n'
+        f'  <strong>Error:</strong> {message}\n'
+        f"</div>"
+    )
+
+
+def _render_unknown_html(block: dict) -> str:
+    """Render an unknown display block type as HTML."""
+    content = html.escape(str(block))
+    return f'<div class="display-block unknown-block"><pre>{content}</pre></div>'
+
+
+_HTML_RENDERERS: dict[str, callable] = {
+    "diff": _render_diff_html,
+    "todo": _render_todo_html,
+    "shell": _render_shell_html,
+    "background_task": _render_bg_task_html,
+    "think": _render_think_html,
+    "code": _render_code_html,
+    "table": _render_table_html,
+    "error": _render_error_html,
+    "unknown": _render_unknown_html,
+}
+
+
+# ── Telegram Renderers ───────────────────────────────────────────────────────
+
+
+def _render_diff_telegram(block: dict) -> str:
+    """Render a diff display block for Telegram (Markdown V2).
+
+    Note: Telegram has limited formatting for diffs, so we keep it simple.
+    """
+    path = block.get("path", "<unknown>")
+    old_text = block.get("old_text", "")
+    new_text = block.get("new_text", "")
+
+    # Escape Telegram Markdown V2 special chars
+    def _esc(text: str) -> str:
+        for c in "_[]()~`>#+-=|{}.!":
+            text = text.replace(c, f"\\{c}")
+        return text
+
+    return f"📝 *{_esc(path)}*\n```diff\n- {_esc('Old')}\n+ {_esc('New')}\n```"
+
+
+def _render_todo_telegram(block: dict) -> str:
+    """Render a todo display block for Telegram (Markdown V2)."""
+    items = block.get("items", [])
+    if not items:
+        return "📋 *Todo List:* Empty"
+
+    def _esc(text: str) -> str:
+        for c in "_[]()~`>#+-=|{}.!":
+            text = text.replace(c, f"\\{c}")
+        return text
+
+    icons = {
+        "pending": "⬜",
+        "in_progress": "🔄",
+        "done": "✅",
+    }
+    lines = ["📋 *Todo List:*"]
+    for item in items:
+        status = item.get("status", "pending")
+        icon = icons.get(status, "⬜")
+        title = _esc(item.get("title", ""))
+        lines.append(f"{icon} {title}")
+    return "\n".join(lines)
+
+
+def _render_shell_telegram(block: dict) -> str:
+    """Render a shell command display block for Telegram."""
+    command = block.get("command", "")
+    return f"```bash\n$ {command}\n```"
+
+
+def _render_bg_task_telegram(block: dict) -> str:
+    """Render a background task display block for Telegram."""
+    task_id = block.get("task_id", "?")
+    kind = block.get("kind", "?")
+    status = block.get("status", "?")
+    description = block.get("description", "")
+
+    icons = {
+        "running": "🔄",
+        "completed": "✅",
+        "failed": "❌",
+        "stopped": "🛑",
+    }
+    icon = icons.get(status, "❓")
+
+    def _esc(text: str) -> str:
+        for c in "_[]()~`>#+-=|{}.!":
+            text = text.replace(c, f"\\{c}")
+        return text
+
+    return f"{icon} *Task `{task_id}`*\n{_esc(description)}\n({_esc(kind)}, {_esc(status)})"
+
+
+def _render_think_telegram(block: dict) -> str:
+    """Render a think display block for Telegram."""
+    thought = block.get("thought", "")
+    return f"💭 *Thinking*\n```\n{thought[:3000]}\n```"
+
+
+def _render_code_telegram(block: dict) -> str:
+    """Render a code display block for Telegram."""
+    code = block.get("code", "")
+    language = block.get("language", "")
+    return f"```{language}\n{code[:3000]}\n```"
+
+
+def _render_table_telegram(block: dict) -> str:
+    """Render a table display block for Telegram."""
+    headers = block.get("headers", [])
+    rows = block.get("rows", [])
+    if not headers and not rows:
+        return "📊 *Table:* Empty"
+
+    def _esc(text: str) -> str:
+        for c in "_[]()~`>#+-=|{}.!":
+            text = text.replace(c, f"\\{c}")
+        return text
+
+    lines = []
+    if headers:
+        lines.append(" | ".join(_esc(str(h)) for h in headers))
+        lines.append("—" * 20)
+    for row in rows:
+        lines.append(" | ".join(_esc(str(c)) for c in row))
+    return "\n".join(lines)
+
+
+def _render_error_telegram(block: dict) -> str:
+    """Render an error display block for Telegram."""
+    message = block.get("message", "Unknown error")
+
+    def _esc(text: str) -> str:
+        for c in "_[]()~`>#+-=|{}.!":
+            text = text.replace(c, f"\\{c}")
+        return text
+
+    return f"❌ *Error:* {_esc(message)}"
+
+
+def _render_unknown_telegram(block: dict) -> str:
+    """Render an unknown display block type for Telegram."""
+    return f"```\n{str(block)[:1000]}\n```"
+
+
+_TG_RENDERERS: dict[str, callable] = {
+    "diff": _render_diff_telegram,
+    "todo": _render_todo_telegram,
+    "shell": _render_shell_telegram,
+    "background_task": _render_bg_task_telegram,
+    "think": _render_think_telegram,
+    "code": _render_code_telegram,
+    "table": _render_table_telegram,
+    "error": _render_error_telegram,
+    "unknown": _render_unknown_telegram,
+}