opencomputer 0.1.0__py3-none-any.whl

opencomputer/setup_wizard.py

@@ -0,0 +1,235 @@
+"""
+opencomputer setup — interactive first-run wizard.
+
+Walks a new user through: pick provider → enter API key → optionally add
+channel tokens → write config.yaml → test the provider connection.
+
+Design notes:
+- Never stores the API key in config.yaml — we ask the user to export it
+  as an env var (the provider reads $ANTHROPIC_API_KEY / $OPENAI_API_KEY
+  natively). Saves the ENV VAR NAME so we can remind the user later.
+- Safe to re-run — each step detects existing config and asks "overwrite?"
+- Provider test is short (just a <10-token ping) to confirm auth works.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from dataclasses import replace
+from pathlib import Path
+
+from rich.console import Console
+from rich.prompt import Confirm, Prompt
+
+from opencomputer.agent.config import (
+    Config,
+    MCPServerConfig,
+    ModelConfig,
+    default_config,
+)
+from opencomputer.agent.config_store import (
+    config_file_path,
+    load_config,
+    save_config,
+)
+
+console = Console()
+
+
+# Known providers the wizard supports out of the box. Adding a new provider
+# plugin? It'll still work — the user can edit config.yaml by hand.
+_SUPPORTED_PROVIDERS = {
+    "anthropic": {
+        "label": "Anthropic (Claude)",
+        "env_key": "ANTHROPIC_API_KEY",
+        "default_model": "claude-opus-4-7",
+        "signup_url": "https://console.anthropic.com/settings/keys",
+    },
+    "openai": {
+        "label": "OpenAI (GPT)",
+        "env_key": "OPENAI_API_KEY",
+        "default_model": "gpt-5.4",
+        "signup_url": "https://platform.openai.com/api-keys",
+    },
+}
+
+
+def _print_banner() -> None:
+    console.print("\n[bold cyan]╭─────────────────────────────────────╮[/bold cyan]")
+    console.print("[bold cyan]│    OpenComputer — Setup Wizard      │[/bold cyan]")
+    console.print("[bold cyan]╰─────────────────────────────────────╯[/bold cyan]")
+    console.print()
+
+
+def _pick_provider() -> tuple[str, dict]:
+    console.print("[bold]Step 1 — pick an LLM provider[/bold]")
+    for i, (pid, meta) in enumerate(_SUPPORTED_PROVIDERS.items(), 1):
+        console.print(f"  [cyan]{i}[/cyan]. {meta['label']} — [dim]{pid}[/dim]")
+    while True:
+        choice = Prompt.ask(
+            "Choose", default="1", choices=[str(i) for i in range(1, len(_SUPPORTED_PROVIDERS) + 1)]
+        )
+        try:
+            idx = int(choice) - 1
+        except ValueError:
+            continue
+        pid = list(_SUPPORTED_PROVIDERS.keys())[idx]
+        return pid, _SUPPORTED_PROVIDERS[pid]
+
+
+def _prompt_model(default_model: str) -> str:
+    console.print(f"\n[bold]Step 2 — which model?[/bold] [dim](default: {default_model})[/dim]")
+    return Prompt.ask("Model", default=default_model)
+
+
+def _prompt_api_key(env_key: str, signup_url: str) -> None:
+    console.print("\n[bold]Step 3 — API key[/bold]")
+    console.print(f"[dim]Get one at {signup_url} if you don't have it yet.[/dim]")
+
+    current = os.environ.get(env_key, "")
+    if current:
+        console.print(
+            f"[green]✓[/green] {env_key} is already set in your environment "
+            f"(ends in …{current[-4:]})."
+        )
+        return
+
+    console.print(
+        f"[yellow]![/yellow] {env_key} is NOT set. "
+        f"Before running, export it in your shell:"
+    )
+    console.print(f"  [bold]export {env_key}=your-key-here[/bold]")
+    console.print(
+        "[dim]Tip: add it to ~/.zshrc or ~/.bashrc to persist across sessions.[/dim]"
+    )
+
+
+def _optional_channel(cfg: Config) -> None:
+    console.print("\n[bold]Step 4 — messaging channel (optional)[/bold]")
+    console.print("[dim]Skip if you only want to use the CLI for now.[/dim]")
+
+    want_telegram = Confirm.ask("Set up Telegram?", default=False)
+    if want_telegram:
+        console.print(
+            "1. Open Telegram → message @BotFather → /newbot\n"
+            "2. Name the bot, get the token.\n"
+            "3. Export the token:"
+        )
+        console.print("   [bold]export TELEGRAM_BOT_TOKEN=123:ABC...[/bold]")
+        console.print(
+            "[dim]Then run `opencomputer gateway` — the Telegram plugin "
+            "picks up the token automatically.[/dim]"
+        )
+
+
+def _optional_mcp(cfg: Config) -> Config:
+    console.print("\n[bold]Step 5 — MCP servers (optional)[/bold]")
+    console.print(
+        "[dim]MCP servers expose external tools to the agent "
+        "(stock prices, databases, browsers, etc.)[/dim]"
+    )
+    want_mcp = Confirm.ask("Add an MCP server?", default=False)
+    if not want_mcp:
+        return cfg
+
+    servers: list[MCPServerConfig] = list(cfg.mcp.servers)
+    while True:
+        name = Prompt.ask("Server name (kebab-case, e.g. 'investor-agent')")
+        if not name.strip():
+            break
+        command = Prompt.ask("Command to launch it (e.g. 'python3')")
+        args_str = Prompt.ask(
+            "Args (space-separated, e.g. '-m investor_agent.server')", default=""
+        )
+        args = tuple(args_str.split()) if args_str else ()
+        servers.append(
+            MCPServerConfig(name=name, command=command, args=args, enabled=True)
+        )
+        console.print(f"[green]✓[/green] added {name}")
+        if not Confirm.ask("Add another?", default=False):
+            break
+
+    return replace(cfg, mcp=replace(cfg.mcp, servers=tuple(servers)))
+
+
+async def _test_provider(provider_id: str, env_key: str) -> bool:
+    """Fire one tiny request to confirm auth works. Returns True on success."""
+    if not os.environ.get(env_key):
+        console.print(
+            f"[yellow]skipped[/yellow] — {env_key} not set, can't test auth yet"
+        )
+        return False
+
+    from opencomputer.agent.config import default_config
+    from opencomputer.plugins.registry import registry as plugin_registry
+    from plugin_sdk.core import Message
+
+    # Discover + activate providers
+    repo_root = Path(__file__).resolve().parent.parent
+    ext_dir = repo_root / "extensions"
+    if ext_dir.exists():
+        plugin_registry.load_all([ext_dir])
+
+    provider_cls = plugin_registry.providers.get(provider_id)
+    if provider_cls is None:
+        console.print(f"[red]✗[/red] provider plugin for '{provider_id}' not found")
+        return False
+
+    try:
+        provider = provider_cls() if isinstance(provider_cls, type) else provider_cls
+        resp = await provider.complete(
+            model=default_config().model.model if provider_id == "anthropic" else "gpt-5.4",
+            messages=[Message(role="user", content="reply with exactly: OK")],
+            max_tokens=8,
+        )
+        console.print(
+            f"[green]✓[/green] provider responded — "
+            f"{resp.usage.input_tokens} in / {resp.usage.output_tokens} out tokens"
+        )
+        return True
+    except Exception as e:  # noqa: BLE001
+        console.print(f"[red]✗[/red] provider test failed: {type(e).__name__}: {e}")
+        return False
+
+
+def run_setup() -> None:
+    """Interactive setup wizard entry point."""
+    _print_banner()
+
+    existing = config_file_path().exists()
+    if existing:
+        console.print(
+            f"[yellow]![/yellow] Existing config found at [dim]{config_file_path()}[/dim]"
+        )
+        if not Confirm.ask("Overwrite?", default=False):
+            console.print("[dim]Aborted.[/dim]")
+            return
+
+    cfg = load_config() if existing else default_config()
+    provider_id, meta = _pick_provider()
+    model = _prompt_model(meta["default_model"])
+    new_model_cfg = ModelConfig(
+        provider=provider_id,
+        model=model,
+        api_key_env=meta["env_key"],
+    )
+    cfg = replace(cfg, model=new_model_cfg)
+
+    _prompt_api_key(meta["env_key"], meta["signup_url"])
+    _optional_channel(cfg)
+    cfg = _optional_mcp(cfg)
+
+    save_config(cfg)
+    console.print(f"\n[green]✓[/green] wrote config → [dim]{config_file_path()}[/dim]")
+
+    console.print("\n[bold]Step 6 — test the provider connection[/bold]")
+    if Confirm.ask("Send a tiny test request now?", default=True):
+        asyncio.run(_test_provider(provider_id, meta["env_key"]))
+
+    console.print(
+        "\n[bold green]Setup complete.[/bold green] Run [bold]opencomputer[/bold] to chat."
+    )
+
+
+__all__ = ["run_setup"]

opencomputer/skills/debug-python-import-error/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: Debug Python import error
+description: Use when the user hits a ModuleNotFoundError, ImportError, ImportError when running a Python script, circular import, "no module named X", or asks about fixing a broken Python import.
+version: 0.1.0
+---
+
+# Debugging Python Import Errors
+
+When the user hits an import error, follow this systematic checklist.
+
+## 1. Identify the exact error
+
+Look at the traceback — the key things to extract:
+- Exact module name that failed (`ModuleNotFoundError: No module named 'foo'`)
+- Which file triggered the import
+- Any partial match (sometimes `X.Y` fails where `X` works — points to a missing submodule)
+
+## 2. The 4 most common causes (check in order)
+
+### A. Missing dependency
+Most common. Package simply isn't installed.
+- Check: `pip list | grep <module>` or `python -c "import <module>"`
+- Fix: `pip install <module>` (or `pip install -e .` if editable in-project)
+
+### B. Virtual environment not activated
+The script is running against system Python, not the venv.
+- Check: `which python` and `echo $VIRTUAL_ENV`
+- Fix: `source .venv/bin/activate` (or equivalent)
+
+### C. Wrong working directory / sys.path
+Package lives somewhere not on `sys.path`.
+- Check: `python -c "import sys; print(sys.path)"`
+- Check: is the project installed with `pip install -e .`? That adds src to path.
+- Fix: install in editable mode or use `PYTHONPATH=...`.
+
+### D. Circular import
+`A` imports `B` which imports `A` back.
+- Signal: error says "partially initialized module" or "cannot import name X from Y"
+- Fix: restructure — extract the shared piece into a third module that both import.
+
+## 3. Plugin/extension specific (OpenComputer)
+
+If the error is in an OpenComputer plugin:
+- Plugin entry module names collide — check `opencomputer/plugins/loader.py` — we clear common names between plugin loads.
+- `from X import Y` at top of plugin.py — use the try/except ImportError dual pattern or `importlib.util.spec_from_file_location`.
+
+## 4. Verify the fix
+
+After making a change:
+```bash
+python -c "import <module>; print('OK')"
+# or run the failing script again
+```
+
+## 5. Save the root cause
+
+If this was a non-obvious fix (circular import fix, sys.path trick), save it
+to a skill so you don't debug it again next time.

opencomputer/tools/__init__.py

@@ -0,0 +1 @@
+"""Built-in tools — Read, Write, Bash, Grep, Glob, skill_manage, delegate."""

opencomputer/tools/bash.py

@@ -0,0 +1,78 @@
+"""Bash tool — run a shell command with a timeout."""
+
+from __future__ import annotations
+
+import asyncio
+
+from plugin_sdk.core import ToolCall, ToolResult
+from plugin_sdk.tool_contract import BaseTool, ToolSchema
+
+
+class BashTool(BaseTool):
+    parallel_safe = False  # side effects
+
+    @property
+    def schema(self) -> ToolSchema:
+        return ToolSchema(
+            name="Bash",
+            description="Execute a bash command and return stdout+stderr. "
+            "Commands run in /bin/bash with a configurable timeout. "
+            "Use for scripted tasks, git, package management, file ops.",
+            parameters={
+                "type": "object",
+                "properties": {
+                    "command": {
+                        "type": "string",
+                        "description": "The bash command to execute.",
+                    },
+                    "timeout_s": {
+                        "type": "integer",
+                        "description": "Max execution time in seconds (default 60, max 600).",
+                        "minimum": 1,
+                        "maximum": 600,
+                    },
+                },
+                "required": ["command"],
+            },
+        )
+
+    async def execute(self, call: ToolCall) -> ToolResult:
+        args = call.arguments
+        cmd = args.get("command", "")
+        timeout = min(int(args.get("timeout_s", 60)), 600)
+        if not cmd.strip():
+            return ToolResult(
+                tool_call_id=call.id, content="Error: empty command", is_error=True
+            )
+        try:
+            proc = await asyncio.create_subprocess_shell(
+                cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+            exit_code = proc.returncode or 0
+        except TimeoutError:
+            return ToolResult(
+                tool_call_id=call.id,
+                content=f"Error: command timed out after {timeout}s",
+                is_error=True,
+            )
+        except Exception as e:
+            return ToolResult(
+                tool_call_id=call.id,
+                content=f"Error: {type(e).__name__}: {e}",
+                is_error=True,
+            )
+
+        out = stdout.decode("utf-8", errors="replace") if stdout else ""
+        err = stderr.decode("utf-8", errors="replace") if stderr else ""
+        combined = (
+            f"$ {cmd}\n"
+            f"exit={exit_code}\n"
+            f"--- stdout ---\n{out}"
+            + (f"\n--- stderr ---\n{err}" if err else "")
+        )
+        return ToolResult(
+            tool_call_id=call.id, content=combined, is_error=exit_code != 0
+        )

opencomputer/tools/delegate.py

@@ -0,0 +1,98 @@
+"""
+delegate — spawn a fresh subagent in an isolated context.
+
+Used when the main agent wants to offload a big exploration task without
+polluting its own context. The subagent gets a fresh system prompt +
+whatever briefing the main agent writes, runs its own while-loop, and
+returns a single text summary.
+
+Phase 1.5 stub: uses a simple approach where the subagent shares the
+provider + tool registry, but keeps its own conversation messages.
+Later phases can add context isolation, tool restrictions, etc.
+"""
+
+from __future__ import annotations
+
+from plugin_sdk.core import ToolCall, ToolResult
+from plugin_sdk.runtime_context import DEFAULT_RUNTIME_CONTEXT, RuntimeContext
+from plugin_sdk.tool_contract import BaseTool, ToolSchema
+
+
+class DelegateTool(BaseTool):
+    parallel_safe = True  # each delegate gets its own loop instance
+
+    # Lazy-import a factory the CLI can inject; until then raise a clear error
+    _factory = None
+    #: Class-level "current runtime" set by the parent loop before dispatching
+    #: tool calls. Ensures subagent loops inherit plan_mode / yolo_mode, etc.
+    _current_runtime: RuntimeContext = DEFAULT_RUNTIME_CONTEXT
+
+    @classmethod
+    def set_factory(cls, factory) -> None:
+        """Inject a callable that returns a fresh AgentLoop. Called once at CLI startup."""
+        # staticmethod wrap prevents Python from binding `self` when we later do
+        # `self._factory()` on an instance — lambdas and plain functions would
+        # otherwise get `self` auto-injected.
+        cls._factory = staticmethod(factory)
+
+    @classmethod
+    def set_runtime(cls, runtime: RuntimeContext) -> None:
+        """Set the runtime context to propagate into subagents. Called by AgentLoop."""
+        cls._current_runtime = runtime
+
+    @property
+    def schema(self) -> ToolSchema:
+        return ToolSchema(
+            name="delegate",
+            description=(
+                "Spawn a fresh subagent with isolated context to handle a specific task. "
+                "Use this when you need to do heavy exploration (reading many files, searching "
+                "code) and only want a summary back instead of polluting the main conversation. "
+                "The subagent runs until it produces a final answer, then returns its output."
+            ),
+            parameters={
+                "type": "object",
+                "properties": {
+                    "task": {
+                        "type": "string",
+                        "description": (
+                            "Describe the task for the subagent completely. The subagent has "
+                            "no memory of the main conversation — include all context it needs."
+                        ),
+                    },
+                },
+                "required": ["task"],
+            },
+        )
+
+    async def execute(self, call: ToolCall) -> ToolResult:
+        task = call.arguments.get("task", "").strip()
+        if not task:
+            return ToolResult(
+                tool_call_id=call.id,
+                content="Error: task description required",
+                is_error=True,
+            )
+        if self._factory is None:
+            return ToolResult(
+                tool_call_id=call.id,
+                content=(
+                    "Error: delegate is not initialized. "
+                    "CLI bootstrapping must call DelegateTool.set_factory(...)."
+                ),
+                is_error=True,
+            )
+        subagent_loop = self._factory()
+        # Propagate the parent's runtime context — plan mode, yolo mode, etc.
+        # must apply to subagents too, otherwise delegating becomes an escape hatch.
+        result = await subagent_loop.run_conversation(
+            user_message=task,
+            runtime=self._current_runtime,
+        )
+        return ToolResult(
+            tool_call_id=call.id,
+            content=result.final_message.content,
+        )
+
+
+__all__ = ["DelegateTool"]

opencomputer/tools/glob.py

@@ -0,0 +1,70 @@
+"""Glob tool — find files by pattern, sorted by mtime."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from plugin_sdk.core import ToolCall, ToolResult
+from plugin_sdk.tool_contract import BaseTool, ToolSchema
+
+
+class GlobTool(BaseTool):
+    parallel_safe = True
+
+    @property
+    def schema(self) -> ToolSchema:
+        return ToolSchema(
+            name="Glob",
+            description=(
+                "Find files matching a glob pattern. Returns paths sorted by modification "
+                "time (newest first). Supports recursive patterns like '**/*.py'."
+            ),
+            parameters={
+                "type": "object",
+                "properties": {
+                    "pattern": {
+                        "type": "string",
+                        "description": "Glob pattern, e.g. '**/*.py' or 'src/**/*.ts'.",
+                    },
+                    "path": {
+                        "type": "string",
+                        "description": "Root to search from. Defaults to cwd.",
+                    },
+                    "max_results": {
+                        "type": "integer",
+                        "description": "Cap the result count. Default 500.",
+                    },
+                },
+                "required": ["pattern"],
+            },
+        )
+
+    async def execute(self, call: ToolCall) -> ToolResult:
+        args = call.arguments
+        pattern = args.get("pattern", "")
+        path = args.get("path", ".")
+        max_results = int(args.get("max_results", 500))
+
+        if not pattern:
+            return ToolResult(
+                tool_call_id=call.id, content="Error: pattern required", is_error=True
+            )
+        root = Path(path)
+        if not root.exists():
+            return ToolResult(
+                tool_call_id=call.id,
+                content=f"Error: path does not exist: {root}",
+                is_error=True,
+            )
+
+        matches = list(root.glob(pattern))
+        matches = [p for p in matches if p.is_file()]
+        matches.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+        matches = matches[:max_results]
+
+        if not matches:
+            return ToolResult(tool_call_id=call.id, content="(no matches)")
+        return ToolResult(
+            tool_call_id=call.id,
+            content="\n".join(str(p) for p in matches),
+        )

opencomputer/tools/grep.py

@@ -0,0 +1,117 @@
+"""Grep tool — search file contents with ripgrep if available, else Python fallback."""
+
+from __future__ import annotations
+
+import asyncio
+import re
+import shutil
+from pathlib import Path
+
+from plugin_sdk.core import ToolCall, ToolResult
+from plugin_sdk.tool_contract import BaseTool, ToolSchema
+
+
+class GrepTool(BaseTool):
+    parallel_safe = True
+
+    @property
+    def schema(self) -> ToolSchema:
+        return ToolSchema(
+            name="Grep",
+            description=(
+                "Search for a regex pattern in files. Uses ripgrep if available, "
+                "falls back to pure Python. Returns matching lines with file:line prefix."
+            ),
+            parameters={
+                "type": "object",
+                "properties": {
+                    "pattern": {
+                        "type": "string",
+                        "description": "Regex pattern to search for.",
+                    },
+                    "path": {
+                        "type": "string",
+                        "description": "Directory or file to search in. Defaults to cwd.",
+                    },
+                    "glob": {
+                        "type": "string",
+                        "description": "Optional glob filter (e.g. '*.py').",
+                    },
+                    "case_insensitive": {
+                        "type": "boolean",
+                        "description": "Case-insensitive match (-i). Default false.",
+                    },
+                    "max_results": {
+                        "type": "integer",
+                        "description": "Cap the number of matches. Default 200.",
+                    },
+                },
+                "required": ["pattern"],
+            },
+        )
+
+    async def execute(self, call: ToolCall) -> ToolResult:
+        args = call.arguments
+        pattern = args.get("pattern", "")
+        path = args.get("path", ".")
+        glob = args.get("glob", "")
+        case_i = bool(args.get("case_insensitive", False))
+        max_results = int(args.get("max_results", 200))
+
+        if not pattern:
+            return ToolResult(tool_call_id=call.id, content="Error: pattern required", is_error=True)
+
+        rg = shutil.which("rg")
+        if rg:
+            cmd = [rg, "--no-heading", "--line-number", "--color=never"]
+            if case_i:
+                cmd.append("-i")
+            if glob:
+                cmd += ["--glob", glob]
+            cmd += ["--max-count", str(max_results)]
+            cmd += [pattern, path]
+            proc = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            out, err = await proc.communicate()
+            txt = (out or b"").decode("utf-8", errors="replace")
+            return ToolResult(
+                tool_call_id=call.id,
+                content=txt or "(no matches)",
+            )
+
+        # pure-python fallback
+        try:
+            regex = re.compile(pattern, re.IGNORECASE if case_i else 0)
+        except re.error as e:
+            return ToolResult(
+                tool_call_id=call.id, content=f"Error: invalid regex: {e}", is_error=True
+            )
+
+        target = Path(path)
+        files: list[Path]
+        if target.is_file():
+            files = [target]
+        else:
+            files = list(target.rglob(glob or "*"))
+            files = [f for f in files if f.is_file()]
+
+        hits: list[str] = []
+        for f in files:
+            if len(hits) >= max_results:
+                break
+            try:
+                for i, line in enumerate(f.read_text(encoding="utf-8", errors="replace").splitlines(), 1):
+                    if regex.search(line):
+                        hits.append(f"{f}:{i}:{line}")
+                        if len(hits) >= max_results:
+                            break
+            except Exception:
+                continue
+
+        return ToolResult(
+            tool_call_id=call.id,
+            content="\n".join(hits) or "(no matches)",
+        )