dulus 3.10.3__tar.gz → 3.10.4__tar.gz

{dulus-3.10.3/dulus.egg-info → dulus-3.10.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dulus
-Version: 3.10.3
+Version: 3.10.4
 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.10.3 → dulus-3.10.4}/compaction.py

@@ -78,6 +78,27 @@ def estimate_tokens(messages: list, model: str = "", config: dict | None = None,
                 for v in tc.values():
                     if isinstance(v, str):
                         total_chars += len(v)
+        # ── Images / videos (2026-07-13 fix) ──────────────────────────────
+        # agent.py attaches /image and /video payloads as sibling keys
+        # user_msg["images"] / user_msg["videos"] (base64 strings), NOT
+        # inside "content". This loop used to never look at them, so a
+        # single video attachment (often 200-800k+ base64 chars) was
+        # completely invisible to the token estimate. Result: compaction
+        # thought the conversation was small and never fired auto-compact,
+        # while the model actually receiving that payload (e.g. Kimi's
+        # multimodal video support) silently ballooned past its real
+        # context window and degraded. Count them like any other content.
+        for key in ("images", "videos"):
+            items = m.get(key)
+            if not items:
+                continue
+            for item in items:
+                if isinstance(item, str):
+                    total_chars += len(item)
+                elif isinstance(item, dict):
+                    data = item.get("data", "")
+                    if isinstance(data, str):
+                        total_chars += len(data)
     content_tokens = int(total_chars / 2.8)
     framing_tokens = msg_count * 4      # role + delimiters overhead per msg
     return int((content_tokens + framing_tokens) * 1.1)

{dulus-3.10.3 → dulus-3.10.4/dulus.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dulus
-Version: 3.10.3
+Version: 3.10.4
 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.10.3 → dulus-3.10.4}/dulus.py

@@ -5085,6 +5085,7 @@ def cmd_skill(args: str, state, config) -> bool:
         list_awesome_remote, list_composio_toolkits,
         install_awesome_remote,
         list_dulus_remote, install_dulus_remote,
+        search_skillssh, install_skillssh,
     )
     from pathlib import Path as _Path
 
@@ -5122,11 +5123,12 @@ def cmd_skill(args: str, state, config) -> bool:
             print(f"  4) {clr('local', 'yellow')}     — Anthropic + awesome marketplaces on disk (~/.claude/...)")
             print(f"  5) {clr('installed', 'yellow')} — skills already in ~/.dulus/skills/")
             print(f"  6) {clr('all', 'yellow')}       — combine dulus + awesome + composio + local")
+            print(f"  7) {clr('skillssh', 'yellow')}  — skills.sh open directory (100K+ skills, needs a search term)")
             try:
                 choice = input(clr("  > ", "cyan")).strip().lower()
             except (EOFError, KeyboardInterrupt):
                 return True
-            mapping = {"1": "dulus", "2": "awesome", "3": "composio", "4": "local", "5": "installed", "6": "all"}
+            mapping = {"1": "dulus", "2": "awesome", "3": "composio", "4": "local", "5": "installed", "6": "all", "7": "skillssh"}
             rest = mapping.get(choice, choice)
 
         if rest.startswith("dulus"):
@@ -5235,6 +5237,23 @@ def cmd_skill(args: str, state, config) -> bool:
                     print(f"  {clr(r['slug'], 'cyan'):30s}  {r.get('description','')[:60]}")
             return True
 
+        if rest.startswith("skillssh"):
+            q = rest[8:].strip()
+            if not q:
+                info("skills.sh has no browse endpoint — give me a search term: /skill list skillssh <query>")
+                return True
+            info(f"Searching skills.sh for '{q}'...")
+            results = search_skillssh(q, limit=25)
+            if not results:
+                err("No skills found on skills.sh (network or empty result).")
+                return True
+            lines = [
+                f"  {clr(s['id'], 'cyan'):60s}  {s.get('description', '')[:70]}"
+                for s in results
+            ]
+            _pager(f"skills.sh results ({len(results)}) — /skill get <id> to install — n=next q=quit", lines)
+            return True
+
         if rest.startswith("installed"):
             query = rest[9:].strip()
             skills = list_installed(query)
@@ -5342,6 +5361,8 @@ def cmd_skill(args: str, state, config) -> bool:
         if rest.startswith("clawhub:"):
             slug = rest[8:]
             success, msg = install_clawhub(slug)
+        elif rest.startswith("skillssh/"):
+            success, msg = install_skillssh(rest)
         elif rest.startswith("dulus/"):
             success, msg = install_dulus_remote(rest)
         elif rest.startswith("awesome/"):

{dulus-3.10.3 → dulus-3.10.4}/dulus_mcp/client.py

@@ -36,6 +36,17 @@ class StdioTransport:
 
     def start(self) -> None:
         env = {**os.environ, **(self._config.env or {})}
+        # ── Guard: empty/blank command ────────────────────────────────────
+        # A corrupted or half-filled-out .mcp.json entry (e.g. {"command": ""})
+        # used to reach subprocess.Popen([""], ...) directly. On Windows that
+        # raises a bare OSError [WinError 87] "The parameter is incorrect" with
+        # zero context — impossible to debug from the GUI toast. Fail fast with
+        # a message that names the actual broken server instead.
+        if not (self._config.command or "").strip():
+            raise RuntimeError(
+                f"MCP server '{self._config.name}' has no command configured "
+                f"(empty 'command' field in mcp.json). Fix or remove this entry."
+            )
         # ── Windows launcher resolution ──────────────────────────────────
         # On Windows, node tooling ships as .cmd shims (npx.cmd, npm.cmd) and
         # Python's subprocess won't find a bare "npx" without the extension.
@@ -46,6 +57,14 @@ class StdioTransport:
         _resolved = _shutil.which(_launcher)
         if _resolved:
             _launcher = _resolved
+        elif os.name == "nt" and not _launcher.lower().endswith((".exe", ".cmd", ".bat")):
+            # Launcher wasn't found on PATH at all (typo, uninstalled runtime,
+            # etc). Raise a clean, actionable error instead of letting Popen
+            # attempt to launch a bare/garbled name and blow up with WinError87.
+            raise RuntimeError(
+                f"MCP server '{self._config.name}': launcher '{_launcher}' not found on PATH. "
+                f"Install it or fix the 'command' field in mcp.json."
+            )
         cmd = [_launcher] + list(self._config.args or [])
         # On Windows, .cmd/.bat shims must run through the shell layer.
         _use_shell = os.name == "nt" and str(_launcher).lower().endswith((".cmd", ".bat"))

{dulus-3.10.3 → dulus-3.10.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dulus"
-version = "3.10.3"
+version = "3.10.4"
 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"

{dulus-3.10.3 → dulus-3.10.4}/skill/clawhub.py

@@ -731,6 +731,206 @@ def install_clawhub(slug: str) -> tuple[bool, str]:
     return False, f"ClawHub API endpoint not yet mapped. Try: /skill get local/{slug}"
 
 
+# ── SKILLS.SH (skills.sh — the open agent skills directory) ────────────────
+# skills.sh indexes 100K+ agent skills across GitHub repos. Search hits its
+# public JSON API; install downloads the skill folder straight from the source
+# repo via raw.githubusercontent.com — no npx, no clone. Fallback catalog:
+# skillsdirectory.com public registry.
+
+_SKILLSSH_API = "https://skills.sh/api/search"
+_SKILLSSH_FALLBACK_API = "https://skillsdirectory.com/api/registry"
+_SKILLSSH_TIMEOUT = 15
+
+
+def _skillssh_gh_headers() -> dict:
+    """GitHub API headers — uses GITHUB_TOKEN/GH_TOKEN if present for rate limits."""
+    import os as _os
+    headers = {"User-Agent": "dulus-skill-manager"}
+    token = _os.environ.get("GITHUB_TOKEN") or _os.environ.get("GH_TOKEN")
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    return headers
+
+
+def search_skillssh(query: Optional[str], limit: int = 10) -> list[dict]:
+    """Search skills.sh for skills matching query.
+
+    Returns entries shaped like the other providers:
+      {id: "skillssh/<owner>/<repo>/<skill>", skill, name, description, source}
+    An empty query returns [] (skills.sh has no browse endpoint; use a term).
+    """
+    if not query or not str(query).strip():
+        return []
+
+    url = f"{_SKILLSSH_API}?q={urllib.parse.quote(str(query).strip())}"
+    data = None
+    try:
+        req = urllib.request.Request(url, headers={"User-Agent": "dulus-skill-manager"})
+        with urllib.request.urlopen(req, timeout=_SKILLSSH_TIMEOUT) as resp:
+            data = json.loads(resp.read())
+    except Exception:
+        data = None
+
+    skills: list[dict] = []
+    if data and isinstance(data.get("skills"), list):
+        for it in data["skills"][: max(limit, 1)]:
+            sid = it.get("id", "")            # "owner/repo/skillId"
+            repo = it.get("source", "")       # "owner/repo"
+            name = it.get("skillId") or it.get("name", "")
+            installs = it.get("installs", 0)
+            if not sid or not name:
+                continue
+            skills.append({
+                "id": f"skillssh/{sid}",
+                "skill": name,
+                "name": name,
+                "description": f"{installs:,} installs · {repo} (skills.sh)",
+                "installs": installs,
+                "repo": repo,
+                "source": "skillssh",
+            })
+        return skills
+
+    # Fallback: skillsdirectory.com public registry (no auth, ~97K skills)
+    try:
+        q = urllib.parse.quote(str(query).strip())
+        req = urllib.request.Request(
+            f"{_SKILLSSH_FALLBACK_API}?search={q}",
+            headers={"User-Agent": "dulus-skill-manager"},
+        )
+        with urllib.request.urlopen(req, timeout=_SKILLSSH_TIMEOUT) as resp:
+            reg = json.loads(resp.read())
+        entries = reg if isinstance(reg, list) else reg.get("skills", reg.get("data", []))
+        for it in entries[: max(limit, 1)]:
+            repo = it.get("repository", "") or it.get("repo", "")
+            name = it.get("slug") or it.get("name", "")
+            if not repo or not name:
+                continue
+            skills.append({
+                "id": f"skillssh/{repo}/{name}",
+                "skill": name,
+                "name": name,
+                "description": (it.get("description") or "")[:160],
+                "repo": repo,
+                "source": "skillssh",
+            })
+    except Exception:
+        pass
+    return skills
+
+
+def _skillssh_default_branch(owner_repo: str) -> str:
+    """Resolve a repo's default branch (main/master/…)."""
+    try:
+        req = urllib.request.Request(
+            f"https://api.github.com/repos/{owner_repo}", headers=_skillssh_gh_headers()
+        )
+        with urllib.request.urlopen(req, timeout=_SKILLSSH_TIMEOUT) as resp:
+            return json.loads(resp.read()).get("default_branch", "main")
+    except Exception:
+        return "main"
+
+
+def install_skillssh(slug: str) -> tuple[bool, str]:
+    """Install a skills.sh skill into ~/.dulus/skills/.
+
+    Accepts:  skillssh/<owner>/<repo>/<skill>  ·  <owner>/<repo>/<skill>
+              <owner>/<repo>   (repo whose root SKILL.md IS the skill)
+    Downloads the whole skill folder (SKILL.md + assets/scripts/references)
+    from the source repo and rewrites frontmatter for Dulus.
+    """
+    parts = slug.replace("skillssh/", "", 1).strip("/").split("/")
+    if len(parts) < 2:
+        return False, (
+            f"Invalid skills.sh slug: '{slug}'. "
+            f"Expected <owner>/<repo>/<skill> or <owner>/<repo>."
+        )
+    owner_repo = f"{parts[0]}/{parts[1]}"
+    skill_name = parts[-1] if len(parts) >= 3 else parts[1]
+
+    branch = _skillssh_default_branch(owner_repo)
+
+    # One tree call to locate the skill dir (mirrors the skills-CLI discovery:
+    # skills/<name>/, .claude/skills/<name>/, catalog layouts, or root SKILL.md).
+    tree_url = f"https://api.github.com/repos/{owner_repo}/git/trees/{branch}?recursive=1"
+    try:
+        req = urllib.request.Request(tree_url, headers=_skillssh_gh_headers())
+        with urllib.request.urlopen(req, timeout=_SKILLSSH_TIMEOUT) as resp:
+            tree = json.loads(resp.read())
+    except Exception as e:
+        return False, f"Could not read repo tree for '{owner_repo}': {e}"
+
+    blobs = [
+        it.get("path", "")
+        for it in tree.get("tree", [])
+        if it.get("type") == "blob"
+    ]
+
+    # Candidate SKILL.md paths whose parent dir matches the skill name.
+    want = skill_name.lower()
+    candidates = [
+        p for p in blobs
+        if p.endswith("/SKILL.md") and p.split("/")[-2].lower() == want
+    ]
+    rel_dir = ""
+    if candidates:
+        rel_dir = "/".join(sorted(candidates, key=lambda p: p.count("/"))[0].split("/")[:-1])
+    elif "SKILL.md" in blobs and len(parts) == 2:
+        rel_dir = ""  # root-level skill: the repo itself is the skill
+    else:
+        near = sorted({p.split("/")[-2] for p in blobs if p.endswith("/SKILL.md")})[:8]
+        return False, (
+            f"No SKILL.md found for '{skill_name}' in {owner_repo}. "
+            f"Skills in that repo: {', '.join(near) if near else '(none)'}"
+        )
+
+    dest_dir = DULUS_SKILLS_DIR / skill_name
+    dest_dir.mkdir(parents=True, exist_ok=True)
+
+    prefix = rel_dir + "/" if rel_dir else ""
+    targets = (
+        [p for p in blobs if p.startswith(prefix)] if rel_dir
+        else ["SKILL.md"]
+    )
+
+    raw_base = f"https://raw.githubusercontent.com/{owner_repo}/{branch}"
+    downloaded: list[str] = []
+    for p in targets:
+        rel = p[len(prefix):] if prefix and p.startswith(prefix) else p.split("/")[-1]
+        dst = dest_dir / rel
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            with urllib.request.urlopen(f"{raw_base}/{p}", timeout=_SKILLSSH_TIMEOUT) as r:
+                dst.write_bytes(r.read())
+            downloaded.append(rel)
+        except Exception:
+            pass  # skip files we can't fetch
+
+    skill_md = dest_dir / "SKILL.md"
+    if not skill_md.exists():
+        return False, f"Could not download SKILL.md for '{skill_name}' from {owner_repo}."
+
+    # Rewrite frontmatter for Dulus (keep original description if present)
+    raw = skill_md.read_text(encoding="utf-8")
+    orig = _parse_frontmatter(raw)
+    body = _strip_frontmatter(raw)
+    frontmatter = (
+        f"---\n"
+        f"name: {skill_name}\n"
+        f"description: {orig.get('description', f'Skill from skills.sh ({owner_repo})')}\n"
+        f"source: skillssh\n"
+        f"repo: {owner_repo}\n"
+        f"triggers: [/{skill_name}]\n"
+        f"---\n\n"
+    )
+    skill_md.write_text(frontmatter + body, encoding="utf-8")
+
+    return True, (
+        f"Installed '{skill_name}' from skills.sh ({owner_repo}@{branch}) -> {dest_dir}  "
+        f"({len(downloaded)} files: {', '.join(downloaded[:5])}{'...' if len(downloaded) > 5 else ''})"
+    )
+
+
 # ── Installed skills ───────────────────────────────────────────────────────
 
 def list_installed(query: Optional[str] = None) -> list[dict]: