@scemoon/cdh 1.0.4 → 1.0.5

package/onecode/agent/tools/registry.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import Any, Iterable, Mapping, Optional, Protocol
+from typing import Any, Callable, Iterable, Mapping
 
 from onecode.agent.tools.errors import ToolInputError, ToolPermissionError
 from onecode.agent.tools.protocol import ToolCall, ToolResult
@@ -19,11 +20,19 @@ class ToolSpec:
     max_result_size_chars: int = 20_000
 
 
-class Tool(Protocol):
+class Tool(ABC):
+    @abstractmethod
     def spec(self) -> ToolSpec: ...
 
+    @abstractmethod
     def run(self, tool_input: dict[str, Any]) -> ToolResult: ...
 
+    async def run_async(
+        self, tool_input: dict[str, Any],
+        cancel_check: Callable[[], bool] | None = None,
+    ) -> ToolResult:
+        return self.run(tool_input)
+
 
 class ToolRegistry:
     def __init__(
@@ -68,6 +77,64 @@ class ToolRegistry:
             })
         return schemas
 
+    async def dispatch_async(
+        self,
+        call: ToolCall,
+        cancel_check: Callable[[], bool] | None = None,
+    ) -> ToolResult:
+        tool = self.get(call.name)
+        if tool is None:
+            return ToolResult(
+                name=call.name,
+                output={"error": f"unknown tool: {call.name}"},
+                is_error=True,
+                tool_use_id=call.tool_use_id,
+            )
+        try:
+            spec = tool.spec()
+            validate_json_schema(call.input, spec.input_schema, tool_name=call.name)
+            result = await tool.run_async(call.input, cancel_check=cancel_check)
+            max_chars = spec.max_result_size_chars
+            if max_chars > 0 and isinstance(result.output, str) and len(result.output) > max_chars:
+                result = ToolResult(
+                    name=result.name,
+                    output=result.output[:max_chars]
+                    + f"\n\n[Output truncated to {max_chars} characters]",
+                    is_error=result.is_error,
+                    tool_use_id=result.tool_use_id or call.tool_use_id,
+                    content_type=result.content_type,
+                )
+            if result.tool_use_id is None:
+                return ToolResult(
+                    name=result.name,
+                    output=result.output,
+                    is_error=result.is_error,
+                    tool_use_id=call.tool_use_id,
+                    content_type=result.content_type,
+                )
+            return result
+        except ToolInputError as e:
+            return ToolResult(
+                name=call.name,
+                output={"error": str(e)},
+                is_error=True,
+                tool_use_id=call.tool_use_id,
+            )
+        except ToolPermissionError as e:
+            return ToolResult(
+                name=call.name,
+                output={"error": str(e)},
+                is_error=True,
+                tool_use_id=call.tool_use_id,
+            )
+        except Exception as e:
+            return ToolResult(
+                name=call.name,
+                output={"error": str(e)},
+                is_error=True,
+                tool_use_id=call.tool_use_id,
+            )
+
     def dispatch(
         self,
         call: ToolCall,

package/onecode/agent/tools/sandbox.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
+import asyncio
 import enum
 import os
 import resource
 import subprocess
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Optional
+from typing import Callable, Optional
 
 
 class SandboxMode(enum.Enum):
@@ -77,7 +78,6 @@ class Sandbox:
         bwrap_args.extend(["--uid", str(os.getuid())])
         bwrap_args.extend(["--gid", str(os.getgid())])
 
-        env = " ".join(f"{k}={v}" for k, v in os.environ.items() if k in self.config.env_whitelist or k.startswith("LC_"))
         bwrap_args.extend(["--setenv", "HOME", "/workspace"])
         bwrap_args.extend(["--setenv", "PATH", "/usr/local/sbin:/usr/local/bin:/usr/bin:/bin"])
 
@@ -109,6 +109,24 @@ class Sandbox:
             return self._exec_docker(cmd, timeout)
         return self._exec_direct(cmd, timeout)
 
+    async def exec_async(
+        self, cmd: str, timeout: int = 60,
+        cancel_check: Callable[[], bool] | None = None,
+    ) -> dict:
+        """Async public entry point — supports cancellation mid-execution."""
+        mode = self.config.mode
+
+        if mode == SandboxMode.NONE:
+            return await self._exec_direct_async(cmd, timeout, cancel_check)
+        if mode == SandboxMode.BUBBLEWRAP:
+            if self._check_bwrap_available():
+                return await self._exec_bwrap_async(cmd, timeout, cancel_check)
+            return await self._exec_direct_async(cmd, timeout, cancel_check)
+        if mode == SandboxMode.DOCKER:
+            # Docker exec is async-adaptable via docker-py, but keep sync for now
+            return self._exec_docker(cmd, timeout)
+        return await self._exec_direct_async(cmd, timeout, cancel_check)
+
     def _exec_direct(self, cmd: str, timeout: int) -> dict:
         # Apply resource limits in the *child* process only — calling
         # ``setrlimit`` on the parent (this Python interpreter) shrinks
@@ -130,20 +148,6 @@ class Sandbox:
                 )
             except (ValueError, OSError, resource.error):
                 pass
-            try:
-                resource.setrlimit(
-                    resource.RLIMIT_NPROC, (limits.max_procs, limits.max_procs + 5)
-                )
-            except (ValueError, OSError, resource.error):
-                pass
-            try:
-                resource.setrlimit(
-                    resource.RLIMIT_NOFILE,
-                    (limits.max_open_files, limits.max_open_files + 10),
-                )
-            except (ValueError, OSError, resource.error):
-                pass
-
         try:
             result = subprocess.run(
                 cmd,
@@ -166,6 +170,96 @@ class Sandbox:
         except Exception as e:
             return {"success": False, "error": str(e), "sandbox": "none"}
 
+    async def _exec_direct_async(
+        self, cmd: str, timeout: int,
+        cancel_check: Callable[[], bool] | None = None,
+    ) -> dict:
+        limits = self.config.resource_limits
+
+        def _preexec_apply_rlimits() -> None:
+            try:
+                resource.setrlimit(
+                    resource.RLIMIT_CPU, (limits.cpu_time, limits.cpu_time + 5)
+                )
+            except (ValueError, OSError, resource.error):
+                pass
+            try:
+                mem_bytes = limits.memory_mb * 1024 * 1024
+                resource.setrlimit(
+                    resource.RLIMIT_AS, (mem_bytes, mem_bytes)
+                )
+            except (ValueError, OSError, resource.error):
+                pass
+        process = await asyncio.create_subprocess_shell(
+            cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            cwd=str(self.config.workspace_root),
+            preexec_fn=_preexec_apply_rlimits,
+        )
+        try:
+            if cancel_check is not None and cancel_check():
+                process.terminate()
+                await process.wait()
+                return {"success": False, "error": "Cancelled", "sandbox": "none"}
+            stdout, stderr = await asyncio.wait_for(
+                process.communicate(), timeout=timeout,
+            )
+            stdout = stdout.decode("utf-8", errors="replace") if isinstance(stdout, bytes) else stdout
+            stderr = stderr.decode("utf-8", errors="replace") if isinstance(stderr, bytes) else stderr
+            return {
+                "success": process.returncode == 0,
+                "stdout": stdout,
+                "stderr": stderr,
+                "returncode": process.returncode,
+                "sandbox": "none",
+            }
+        except asyncio.TimeoutError:
+            process.terminate()
+            await process.wait()
+            return {"success": False, "error": "Command timed out", "sandbox": "none"}
+        except Exception as e:
+            process.terminate()
+            await process.wait()
+            return {"success": False, "error": str(e), "sandbox": "none"}
+
+    async def _exec_bwrap_async(
+        self, cmd: str, timeout: int,
+        cancel_check: Callable[[], bool] | None = None,
+    ) -> dict:
+        bwrap_cmd = self._build_bwrap_cmd(cmd)
+        process = await asyncio.create_subprocess_exec(
+            *bwrap_cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            cwd=str(self.config.workspace_root),
+        )
+        try:
+            if cancel_check is not None and cancel_check():
+                process.terminate()
+                await process.wait()
+                return {"success": False, "error": "Cancelled", "sandbox": "bwrap"}
+            stdout, stderr = await asyncio.wait_for(
+                process.communicate(), timeout=timeout,
+            )
+            stdout = stdout.decode("utf-8", errors="replace") if isinstance(stdout, bytes) else stdout
+            stderr = stderr.decode("utf-8", errors="replace") if isinstance(stderr, bytes) else stderr
+            return {
+                "success": process.returncode == 0,
+                "stdout": stdout,
+                "stderr": stderr,
+                "returncode": process.returncode,
+                "sandbox": "bwrap",
+            }
+        except asyncio.TimeoutError:
+            process.terminate()
+            await process.wait()
+            return {"success": False, "error": "Command timed out", "sandbox": "bwrap"}
+        except Exception as e:
+            process.terminate()
+            await process.wait()
+            return {"success": False, "error": str(e), "sandbox": "bwrap"}
+
     def _exec_bwrap(self, cmd: str, timeout: int) -> dict:
         bwrap_cmd = self._build_bwrap_cmd(cmd)
 

package/onecode/agent/tools/skill_tools.py

@@ -3,12 +3,12 @@ from __future__ import annotations
 from typing import Any
 
 from onecode.agent.tools.protocol import ToolResult
-from onecode.agent.tools.registry import ToolSpec
+from onecode.agent.tools.registry import Tool, ToolSpec
 from onecode.skills.loader import SkillLoader
 from onecode.skills.argument_substitution import substitute_arguments
 
 
-class SkillTool:
+class SkillTool(Tool):
     """Run a SKILL.md skill (Clawd-Code pattern)."""
 
     def __init__(self, loader: SkillLoader):

package/onecode/agent/tools/todo_tools.py

@@ -3,10 +3,10 @@ from __future__ import annotations
 from typing import Any
 
 from onecode.agent.tools.protocol import ToolResult
-from onecode.agent.tools.registry import ToolSpec
+from onecode.agent.tools.registry import Tool, ToolSpec
 
 
-class TodoCreateTool:
+class TodoCreateTool(Tool):
     def __init__(self, todo_manager):
         self._tm = todo_manager
 
@@ -14,10 +14,12 @@ class TodoCreateTool:
         return ToolSpec(
             name="TodoCreate",
             description=(
-                "Create a todo (lightweight checklist item) for tracking progress "
-                "in the sidebar. Use for SIMPLE / single-step work (1-3 tool calls). "
-                "For complex multi-step work, prefer delegating via `Spawn` subagent "
-                "and use TodoCreate only to surface the overall plan. Returns todo id."
+                "Create a todo (plan item) for tracking progress. ALL tasks — simple "
+                "or complex — are created via TodoCreate, persisted to .cdh/todos.json, "
+                "and mirrored to the sidebar Plan widget. At execution time, route by "
+                "complexity: simple todos are executed directly; complex todos are "
+                "delegated via `Spawn` (mark with metadata={\"delegate_to\": \"general\"}). "
+                "Returns todo id."
             ),
             input_schema={
                 "type": "object",
@@ -42,7 +44,7 @@ class TodoCreateTool:
 
 
 
-class TodoGetTool:
+class TodoGetTool(Tool):
     def __init__(self, todo_manager):
         self._tm = todo_manager
 
@@ -69,7 +71,7 @@ class TodoGetTool:
 
 
 
-class TodoListTool:
+class TodoListTool(Tool):
     def __init__(self, todo_manager):
         self._tm = todo_manager
 
@@ -95,7 +97,7 @@ class TodoListTool:
 
 
 
-class TodoUpdateTool:
+class TodoUpdateTool(Tool):
     def __init__(self, todo_manager):
         self._tm = todo_manager
 
@@ -137,7 +139,7 @@ class TodoUpdateTool:
 
 
 
-class TodoOutputTool:
+class TodoOutputTool(Tool):
     def __init__(self, todo_manager):
         self._tm = todo_manager
 
@@ -148,20 +150,20 @@ class TodoOutputTool:
             input_schema={
                 "type": "object",
                 "properties": {
-                    "task_id": {"type": "string", "description": "Todo id to get output for"},
+                    "taskId": {"type": "string", "description": "Todo id to get output for"},
                 },
-                "required": ["task_id"],
+                "required": ["taskId"],
             },
         )
 
     def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        todo_id = tool_input.get("task_id", "")
+        todo_id = tool_input.get("taskId", "")
         result = self._tm.get_todo_output(todo_id)
         return ToolResult(name="TodoOutput", output=result)
 
 
 
-class TodoStopTool:
+class TodoStopTool(Tool):
     def __init__(self, todo_manager):
         self._tm = todo_manager
 
@@ -172,17 +174,34 @@ class TodoStopTool:
             input_schema={
                 "type": "object",
                 "properties": {
-                    "task_id": {"type": "string", "description": "Todo id to stop"},
+                    "taskId": {"type": "string", "description": "Todo id to stop"},
                 },
-                "required": ["task_id"],
+                "required": ["taskId"],
             },
         )
 
     def run(self, tool_input: dict[str, Any]) -> ToolResult:
-        todo_id = tool_input.get("task_id", "")
+        todo_id = tool_input.get("taskId", "")
         result = self._tm.update_todo(todo_id, status="completed")
         if result is None:
             return ToolResult(name="TodoStop", output={"success": False, "stopped": False, "error": "Todo not found"}, is_error=True)
         if result.get("deleted"):
-            return ToolResult(name="TodoStop", output={"success": True, "stopped": True, "task_id": todo_id})
-        return ToolResult(name="TodoStop", output={"success": True, "stopped": True, "task_id": todo_id})
+            return ToolResult(name="TodoStop", output={"success": True, "stopped": True, "taskId": todo_id})
+        return ToolResult(name="TodoStop", output={"success": True, "stopped": True, "taskId": todo_id})
+
+
+class TodoClearTool(Tool):
+    def __init__(self, todo_manager):
+        self._tm = todo_manager
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="TodoClear",
+            description="Clear all todos. Resets the entire plan — all pending, in-progress, and completed todos are removed and the plan starts fresh.",
+            input_schema={"type": "object", "properties": {}, "required": []},
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        count = len(self._tm.list_todos())
+        self._tm.clear_todos()
+        return ToolResult(name="TodoClear", output={"cleared": count})

package/onecode/agent/tools/web_tools.py

@@ -8,7 +8,7 @@ from typing import Any, Optional
 import httpx
 
 from onecode.agent.tools.protocol import ToolResult
-from onecode.agent.tools.registry import ToolSpec
+from onecode.agent.tools.registry import Tool, ToolSpec
 
 
 @dataclass
@@ -68,7 +68,7 @@ class WebSearch:
 
         for url in search_urls:
             try:
-                results = self._search_duckduckgo(url, num_results)
+                results = self._search_duckduckgo(url, num_results, query)
                 if results:
                     return results
             except Exception:
@@ -76,7 +76,7 @@ class WebSearch:
 
         return self._search_fallback(query, num_results)
 
-    def _search_duckduckgo(self, url: str, num_results: int) -> str:
+    def _search_duckduckgo(self, url: str, num_results: int, query: str) -> str:
         with httpx.Client(timeout=self.timeout, follow_redirects=True) as client:
             resp = client.get(url)
             resp.raise_for_status()
@@ -84,9 +84,7 @@ class WebSearch:
         html_content = resp.text
         results = []
 
-        result_pattern = re.compile(r'<a class="result__a" href="([^"]+)">([^<]+)</a>.*?<a class="result__snippet"[^>]*>([^<]+)</a>', re.DOTALL)
         snippets = re.findall(r'<a class="result__a" href="([^"]+)">([^<]+)</a>', html_content)
-        snippet_pattern = re.compile(r'<a class="result__a" href="[^"]+">[^<]+</a>.*?(?:<p class="result__snippet">([^<]+)</p>)?', re.DOTALL)
 
         for i, (url, title) in enumerate(snippets[:num_results]):
             snippet_match = re.search(rf'<a class="result__a" href="{re.escape(url)}"[^>]*>[^<]+</a>.*?(?:<p class="result__snippet">([^<]+)</p>|(?:<a class="result__snippet"[^>]*>([^<]+)</a>))?', html_content, re.DOTALL)
@@ -104,6 +102,7 @@ class WebSearch:
         return f"No results found for '{query}'"
 
     def _search_fallback(self, query: str, num_results: int) -> str:
+        """Fallback search using a different method."""
         return f"Web search for '{query}' returned no results. Try using WebFetch to directly access a URL."
 
     def _quote(self, query: str) -> str:
@@ -121,7 +120,7 @@ def websearch(query: str, num_results: int = 5) -> str:
     return searcher.search(query, num_results)
 
 
-class WebFetchTool:
+class WebFetchTool(Tool):
     def spec(self) -> ToolSpec:
         return ToolSpec(
             name="WebFetch",
@@ -146,7 +145,7 @@ class WebFetchTool:
 
 
 
-class WebSearchTool:
+class WebSearchTool(Tool):
     def spec(self) -> ToolSpec:
         return ToolSpec(
             name="WebSearch",

package/onecode/builtin_skills/agent-browser/SKILL.md

@@ -0,0 +1,212 @@
+---
+name: agent-browser
+description: Browser automation via Playwright for web interaction and testing
+enabled: true
+triggers:
+  - browser
+  - playwrith
+  - screenshot
+  - web page
+  - navigate
+  - open url
+  - click element
+  - fill form
+  - scrape
+  - headless
+allowed_tools:
+  - Bash
+  - Read
+  - Write
+phases:
+  - verify
+  - deliver
+---
+
+# Agent Browser
+
+## When to Use
+
+- Navigating to a web page and interacting with it
+- Taking screenshots of pages
+- Filling and submitting forms
+- Clicking buttons, links, and other elements
+- Extracting dynamic content that requires JS execution
+- End-to-end testing of web applications
+- Scraping SPAs (Single Page Applications)
+
+Use **WebFetch** instead for simple GET requests that don't need interaction.
+
+## Setup
+
+```bash
+pip install playwright
+playwright install chromium
+```
+
+Check if already installed:
+
+```bash
+python -c "import playwright; print(playwright.__file__)"
+```
+
+## Basic Usage
+
+### Navigate and Screenshot
+
+```python
+from playwright.sync_api import sync_playwright
+
+with sync_playwright() as p:
+    browser = p.chromium.launch(headless=True)
+    page = browser.new_page()
+    page.goto("https://example.com")
+    page.screenshot(path="screenshot.png", full_page=True)
+    browser.close()
+```
+
+### Fill Form and Submit
+
+```python
+page.fill("input[name='username']", "myuser")
+page.fill("input[name='password']", "mypass")
+page.click("button[type='submit']")
+page.wait_for_url("**/dashboard")
+```
+
+### Extract Content
+
+```python
+# Get text content
+title = page.text_content("h1")
+items = page.query_selector_all(".item")
+for item in items:
+    print(item.inner_text())
+
+# Get HTML
+html = page.content()
+
+# Evaluate JavaScript
+result = page.evaluate("() => document.title")
+```
+
+### Wait Strategies
+
+```python
+page.wait_for_selector(".results")       # element appears
+page.wait_for_load_state("networkidle")  # no network activity
+page.wait_for_timeout(2000)              # sleep 2s
+page.wait_for_url("**/success")          # URL pattern
+```
+
+## Selectors
+
+```python
+# CSS
+page.click(".btn-primary")
+page.click("button[data-id='submit']")
+
+# Text
+page.click("text=Submit")
+page.click("button:has-text('Continue')")
+
+# XPath
+page.click("xpath=//button[@name='login']")
+
+# Role (recommended)
+page.get_by_role("button", name="Submit").click()
+page.get_by_label("Email").fill("user@example.com")
+page.get_by_placeholder("Search...").fill("query")
+```
+
+## Common Patterns
+
+### Login Flow
+
+```python
+page.goto("https://example.com/login")
+page.fill("#email", email)
+page.fill("#password", password)
+page.click("button[type='submit']")
+page.wait_for_url("**/dashboard")
+print("Logined:", page.url)
+page.screenshot(path="after_login.png")
+```
+
+### Paginated Scraping
+
+```python
+results = []
+while True:
+    items = page.query_selector_all(".result-item")
+    for item in items:
+        results.append(item.inner_text())
+    next_btn = page.query_selector(".pagination .next")
+    if not next_btn or next_btn.is_disabled():
+        break
+    next_btn.click()
+    page.wait_for_load_state("networkidle")
+```
+
+### Multi-page Navigation
+
+```python
+pages = ["https://example.com/page1", "https://example.com/page2"]
+for url in pages:
+    page.goto(url, wait_until="domcontentloaded")
+    page.screenshot(path=f"screenshot-{url.split('/')[-1]}.png")
+```
+
+## Executing via Bash
+
+For quick one-off tasks, use `python -c`:
+
+```bash
+python -c "
+from playwright.sync_api import sync_playwright
+with sync_playwright() as p:
+    browser = p.chromium.launch(headless=True)
+    page = browser.new_page()
+    page.goto('https://example.com')
+    print(page.title())
+    browser.close()
+"
+```
+
+Or save a script and execute:
+
+```bash
+cat > /tmp/browser_script.py << 'EOF'
+from playwright.sync_api import sync_playwright
+with sync_playwright() as p:
+    browser = p.chromium.launch(headless=True)
+    page = browser.new_page()
+    ...
+    browser.close()
+EOF
+python /tmp/browser_script.py
+```
+
+## Error Handling
+
+```python
+try:
+    page.goto(url, timeout=30000)
+except Exception as e:
+    print(f"Navigation failed: {e}")
+    page.screenshot(path="error.png")
+
+try:
+    page.click(".missing-button", timeout=5000)
+except Exception:
+    print("Button not found, trying alternative...")
+    page.click(".fallback-button")
+```
+
+## Best Practices
+
+- Always use `headless=True` unless user asks for visible browser
+- Set reasonable timeouts (10-30s for navigation)
+- Close browser after use to free resources
+- Screenshot on errors for debugging
+- Prefer `get_by_role/get_by_label` over fragile CSS selectors
+- Wait for network idle before extracting content

package/onecode/builtin_skills/agent-browser/skill.yaml

@@ -0,0 +1,8 @@
+name: agent-browser
+description: >-
+  Browser automation skill via Playwright. Enables the agent to navigate pages,
+  take screenshots, click elements, fill forms, extract content, and evaluate
+  JavaScript in a headless or headed browser.
+version: 1.0.0
+enabled: true
+entry: SKILL.md