gobby 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

gobby/agents/spawners/headless.py

@@ -9,6 +9,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 from gobby.agents.constants import get_terminal_env_vars
+from gobby.agents.sandbox import SandboxConfig, compute_sandbox_paths, get_sandbox_resolver
 from gobby.agents.spawners.base import HeadlessResult
 
 if TYPE_CHECKING:
@@ -26,11 +27,11 @@ def _get_spawn_utils() -> tuple[
     """Lazy import to avoid circular dependencies."""
     from gobby.agents.spawn import (
         MAX_ENV_PROMPT_LENGTH,
-        _create_prompt_file,
         build_cli_command,
+        create_prompt_file,
     )
 
-    return build_cli_command, _create_prompt_file, MAX_ENV_PROMPT_LENGTH
+    return build_cli_command, create_prompt_file, MAX_ENV_PROMPT_LENGTH
 
 
 class HeadlessSpawner:
@@ -169,6 +170,7 @@ class HeadlessSpawner:
         agent_depth: int = 1,
         max_agent_depth: int = 3,
         prompt: str | None = None,
+        sandbox_config: SandboxConfig | None = None,
     ) -> HeadlessResult:
         """
         Spawn a CLI agent in headless mode.
@@ -184,12 +186,24 @@ class HeadlessSpawner:
             agent_depth: Current nesting depth
             max_agent_depth: Maximum allowed depth
             prompt: Optional initial prompt
+            sandbox_config: Optional sandbox configuration
 
         Returns:
             HeadlessResult with process handle
         """
         build_cli_command, _create_prompt_file, max_env_prompt_length = _get_spawn_utils()
 
+        # Resolve sandbox configuration if enabled
+        sandbox_args: list[str] | None = None
+        sandbox_env: dict[str, str] = {}
+
+        if sandbox_config and sandbox_config.enabled:
+            # Compute sandbox paths based on cwd (workspace)
+            resolved_paths = compute_sandbox_paths(sandbox_config, str(cwd))
+            # Get CLI-specific resolver and generate args/env
+            resolver = get_sandbox_resolver(cli)
+            sandbox_args, sandbox_env = resolver.resolve(sandbox_config, resolved_paths)
+
         # Build command with prompt as CLI argument and auto-approve for autonomous work
         command = build_cli_command(
             cli,
@@ -198,6 +212,7 @@ class HeadlessSpawner:
             auto_approve=True,  # Subagents need to work autonomously
             working_directory=str(cwd) if cli == "codex" else None,
             mode="headless",  # Non-interactive headless mode
+            sandbox_args=sandbox_args,
         )
 
         # Handle prompt for environment variables (backup for hooks/context)
@@ -223,4 +238,8 @@ class HeadlessSpawner:
             prompt_file=prompt_file,
         )
 
+        # Merge sandbox environment variables if present
+        if sandbox_env:
+            env.update(sandbox_env)
+
         return self.spawn(command, cwd, env)

gobby/agents/spawners/prompt_manager.py

@@ -0,0 +1,125 @@
+"""Prompt file management for agent spawning.
+
+Handles creation, cleanup, and tracking of temporary prompt files
+used to pass long prompts to spawned CLI agents.
+"""
+
+from __future__ import annotations
+
+import atexit
+import logging
+import os
+import re
+import tempfile
+import threading
+import uuid
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# Maximum prompt length to pass via environment variable
+# Longer prompts will be written to a temp file
+MAX_ENV_PROMPT_LENGTH = 4096
+
+# Module-level set for tracking prompt files to clean up on exit
+# This avoids registering a new atexit handler for each prompt file
+_prompt_files_to_cleanup: set[Path] = set()
+_atexit_registered = False
+_atexit_lock = threading.Lock()
+
+
+def cleanup_all_prompt_files() -> None:
+    """Clean up all tracked prompt files on process exit."""
+    with _atexit_lock:
+        files_to_cleanup = list(_prompt_files_to_cleanup)
+        _prompt_files_to_cleanup.clear()
+        for prompt_path in files_to_cleanup:
+            try:
+                if prompt_path.exists():
+                    prompt_path.unlink()
+            except OSError:
+                pass
+
+
+def create_prompt_file(prompt: str, session_id: str) -> str:
+    """
+    Create a prompt file with secure permissions.
+
+    The file is created in the system temp directory with restrictive
+    permissions (owner read/write only) and tracked for cleanup on exit.
+
+    Args:
+        prompt: The prompt content to write
+        session_id: Session ID for naming the file
+
+    Returns:
+        Path to the created temp file
+    """
+    global _atexit_registered
+
+    # Create temp directory with restrictive permissions
+    temp_dir = Path(tempfile.gettempdir()) / "gobby-prompts"
+    temp_dir.mkdir(parents=True, exist_ok=True, mode=0o700)
+
+    # Sanitize session_id to prevent path traversal attacks
+    # Strip path separators and limit to alphanumeric, hyphens, underscores
+    safe_session_id = re.sub(r"[^a-zA-Z0-9_-]", "", session_id)
+    if not safe_session_id or len(safe_session_id) > 128:
+        safe_session_id = str(uuid.uuid4())
+
+    # Create the prompt file path
+    prompt_path = temp_dir / f"prompt-{safe_session_id}.txt"
+
+    # Write with secure permissions atomically - create with mode 0o600 from the start
+    # This avoids the TOCTOU window between write_text and chmod
+    fd = os.open(str(prompt_path), os.O_CREAT | os.O_WRONLY | os.O_TRUNC, 0o600)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            f.write(prompt)
+            f.flush()
+            os.fsync(f.fileno())
+    except Exception:
+        # fd is closed by fdopen, but if fdopen fails we need to close it
+        try:
+            os.close(fd)
+        except OSError:
+            pass
+        raise
+
+    # Track for cleanup and register handler (thread-safe)
+    with _atexit_lock:
+        _prompt_files_to_cleanup.add(prompt_path)
+        if not _atexit_registered:
+            atexit.register(cleanup_all_prompt_files)
+            _atexit_registered = True
+
+    logger.debug(f"Created secure prompt file: {prompt_path}")
+    return str(prompt_path)
+
+
+def read_prompt_from_env() -> str | None:
+    """
+    Read initial prompt from environment variables.
+
+    Checks GOBBY_PROMPT_FILE first (for long prompts),
+    then falls back to GOBBY_PROMPT (for short prompts).
+
+    Returns:
+        Prompt string or None if not set
+    """
+    from gobby.agents.constants import GOBBY_PROMPT, GOBBY_PROMPT_FILE
+
+    # Check for prompt file first
+    prompt_file = os.environ.get(GOBBY_PROMPT_FILE)
+    if prompt_file:
+        try:
+            prompt_path = Path(prompt_file)
+            if prompt_path.exists():
+                return prompt_path.read_text(encoding="utf-8")
+            else:
+                logger.warning(f"Prompt file not found: {prompt_file}")
+        except Exception as e:
+            logger.error(f"Error reading prompt file: {e}")
+
+    # Fall back to inline prompt
+    return os.environ.get(GOBBY_PROMPT)

gobby/cli/__init__.py

@@ -8,6 +8,8 @@ from gobby.config.app import load_config
 
 from .agents import agents
 from .artifacts import artifacts
+from .clones import clones
+from .conductor import conductor
 from .daemon import restart, start, status, stop
 from .extensions import hooks, plugins, webhooks
 from .github import github
@@ -20,6 +22,7 @@ from .memory import memory
 from .merge import merge
 from .projects import projects
 from .sessions import sessions
+from .skills import skills
 from .tasks import tasks
 from .tui import ui
 from .workflows import workflows
@@ -52,6 +55,7 @@ cli.add_command(uninstall)
 cli.add_command(tasks)
 cli.add_command(memory)
 cli.add_command(sessions)
+cli.add_command(skills)
 cli.add_command(agents)
 cli.add_command(worktrees)
 cli.add_command(mcp_proxy)
@@ -61,6 +65,8 @@ cli.add_command(merge)
 cli.add_command(artifacts)
 cli.add_command(github)
 cli.add_command(linear)
+cli.add_command(clones)
+cli.add_command(conductor)
 cli.add_command(hooks)
 cli.add_command(plugins)
 cli.add_command(webhooks)

gobby/cli/clones.py

@@ -0,0 +1,419 @@
+"""
+Clone management CLI commands.
+
+Commands for managing git clones:
+- create: Create a new clone
+- list: List clones
+- spawn: Spawn an agent in a clone
+- sync: Sync a clone with remote
+- merge: Merge clone branch to target
+- delete: Delete a clone
+"""
+
+import json
+
+import click
+import httpx
+
+from gobby.storage.clones import LocalCloneManager
+from gobby.storage.database import LocalDatabase
+
+
+def get_clone_manager() -> LocalCloneManager:
+    """Get initialized clone manager."""
+    db = LocalDatabase()
+    return LocalCloneManager(db)
+
+
+def get_daemon_url() -> str:
+    """Get daemon URL from config."""
+    from gobby.config.app import load_config
+
+    config = load_config()
+    return f"http://localhost:{config.daemon_port}"
+
+
+@click.group()
+def clones() -> None:
+    """Manage git clones for parallel development."""
+    pass
+
+
+@clones.command("list")
+@click.option("--status", "-s", help="Filter by status (active, stale, syncing, cleanup)")
+@click.option("--project", "-p", "project_id", help="Filter by project ID")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def list_clones(
+    status: str | None,
+    project_id: str | None,
+    json_format: bool,
+) -> None:
+    """List clones."""
+    manager = get_clone_manager()
+
+    clones_list = manager.list_clones(status=status, project_id=project_id)
+
+    if json_format:
+        click.echo(json.dumps([c.to_dict() for c in clones_list], indent=2, default=str))
+        return
+
+    if not clones_list:
+        click.echo("No clones found.")
+        return
+
+    click.echo(f"Found {len(clones_list)} clone(s):\n")
+    for clone in clones_list:
+        status_icon = {
+            "active": "●",
+            "syncing": "↻",
+            "stale": "○",
+            "cleanup": "✗",
+        }.get(clone.status, "?")
+
+        session_info = f" (session: {clone.agent_session_id[:8]})" if clone.agent_session_id else ""
+        click.echo(
+            f"{status_icon} {clone.id}  {clone.branch_name:<30} {clone.status:<10}{session_info}"
+        )
+
+
+@clones.command("create")
+@click.argument("branch_name")
+@click.argument("clone_path")
+@click.option("--base", "-b", "base_branch", default="main", help="Base branch to clone from")
+@click.option("--task", "-t", "task_id", help="Link clone to a task")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def create_clone(
+    branch_name: str,
+    clone_path: str,
+    base_branch: str,
+    task_id: str | None,
+    json_format: bool,
+) -> None:
+    """Create a new clone for parallel development.
+
+    Examples:
+
+        gobby clones create feature/my-feature /path/to/clone
+
+        gobby clones create bugfix/fix-123 /tmp/fix --base develop --task #47
+    """
+    daemon_url = get_daemon_url()
+
+    arguments = {
+        "branch_name": branch_name,
+        "clone_path": clone_path,
+        "base_branch": base_branch,
+    }
+
+    if task_id:
+        arguments["task_id"] = task_id
+
+    try:
+        response = httpx.post(
+            f"{daemon_url}/mcp/gobby-clones/tools/create_clone",
+            json=arguments,
+            timeout=300.0,  # Clone can take a while
+        )
+        response.raise_for_status()
+        result = response.json()
+    except httpx.ConnectError:
+        click.echo("Error: Cannot connect to Gobby daemon. Is it running?", err=True)
+        return
+    except httpx.HTTPStatusError as e:
+        click.echo(f"HTTP Error {e.response.status_code}: {e.response.text}", err=True)
+        return
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        return
+
+    if json_format:
+        click.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    if result.get("success"):
+        clone_info = result.get("clone", {})
+        click.echo(f"Created clone: {clone_info.get('id', 'unknown')}")
+        click.echo(f"  Branch: {clone_info.get('branch_name', 'unknown')}")
+    else:
+        click.echo(f"Failed to create clone: {result.get('error')}", err=True)
+
+
+@clones.command("spawn")
+@click.argument("clone_ref")
+@click.argument("prompt")
+@click.option(
+    "--parent-session-id",
+    "-p",
+    "parent_session_id",
+    required=True,
+    help="Parent session ID (required)",
+)
+@click.option("--mode", "-m", default="terminal", help="Agent mode (terminal, embedded, headless)")
+@click.option("--workflow", "-w", help="Workflow to activate")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def spawn_agent(
+    clone_ref: str,
+    prompt: str,
+    parent_session_id: str,
+    mode: str,
+    workflow: str | None,
+    json_format: bool,
+) -> None:
+    """Spawn an agent to work in a clone.
+
+    Examples:
+
+        gobby clones spawn clone-123 "Fix the authentication bug"
+
+        gobby clones spawn clone-123 "Implement feature" --mode headless
+    """
+    manager = get_clone_manager()
+    clone_id = resolve_clone_id(manager, clone_ref)
+
+    if not clone_id:
+        click.echo(f"Clone not found: {clone_ref}", err=True)
+        return
+
+    daemon_url = get_daemon_url()
+
+    arguments = {
+        "clone_id": clone_id,
+        "prompt": prompt,
+        "parent_session_id": parent_session_id,
+        "mode": mode,
+    }
+
+    if workflow:
+        arguments["workflow"] = workflow
+
+    try:
+        response = httpx.post(
+            f"{daemon_url}/mcp/gobby-clones/tools/spawn_agent_in_clone",
+            json=arguments,
+            timeout=60.0,
+        )
+        response.raise_for_status()
+        result = response.json()
+    except httpx.ConnectError:
+        click.echo("Error: Cannot connect to Gobby daemon. Is it running?", err=True)
+        return
+    except httpx.HTTPStatusError as e:
+        click.echo(f"HTTP Error {e.response.status_code}: {e.response.text}", err=True)
+        return
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        return
+
+    if json_format:
+        click.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    if result.get("success"):
+        session_id = result.get("session_id", "unknown")
+        click.echo(f"Spawned agent in clone {clone_id}")
+        click.echo(f"  Session: {session_id}")
+    else:
+        click.echo(f"Failed to spawn agent: {result.get('error')}", err=True)
+
+
+@clones.command("sync")
+@click.argument("clone_ref")
+@click.option("--direction", "-d", default="pull", help="Sync direction (pull, push, both)")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def sync_clone(clone_ref: str, direction: str, json_format: bool) -> None:
+    """Sync clone with remote.
+
+    Examples:
+
+        gobby clones sync clone-123
+
+        gobby clones sync clone-123 --direction push
+    """
+    manager = get_clone_manager()
+    clone_id = resolve_clone_id(manager, clone_ref)
+
+    if not clone_id:
+        click.echo(f"Clone not found: {clone_ref}", err=True)
+        return
+
+    daemon_url = get_daemon_url()
+
+    try:
+        response = httpx.post(
+            f"{daemon_url}/mcp/gobby-clones/tools/sync_clone",
+            json={"clone_id": clone_id, "direction": direction},
+            timeout=120.0,
+        )
+        response.raise_for_status()
+        result = response.json()
+    except httpx.ConnectError:
+        click.echo("Error: Cannot connect to Gobby daemon. Is it running?", err=True)
+        return
+    except httpx.HTTPStatusError as e:
+        click.echo(f"HTTP Error {e.response.status_code}: {e.response.text}", err=True)
+        return
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        return
+
+    if json_format:
+        click.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    if result.get("success"):
+        click.echo(f"Synced clone {clone_id}")
+    else:
+        click.echo(f"Failed to sync clone: {result.get('error')}", err=True)
+
+
+@clones.command("merge")
+@click.argument("clone_ref")
+@click.option("--target", "-t", "target_branch", default="main", help="Target branch to merge into")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def merge_clone(clone_ref: str, target_branch: str, json_format: bool) -> None:
+    """Merge clone branch to target branch.
+
+    Examples:
+
+        gobby clones merge clone-123
+
+        gobby clones merge clone-123 --target develop
+    """
+    manager = get_clone_manager()
+    clone_id = resolve_clone_id(manager, clone_ref)
+
+    if not clone_id:
+        click.echo(f"Clone not found: {clone_ref}", err=True)
+        return
+
+    daemon_url = get_daemon_url()
+
+    try:
+        response = httpx.post(
+            f"{daemon_url}/mcp/gobby-clones/tools/merge_clone_to_target",
+            json={"clone_id": clone_id, "target_branch": target_branch},
+            timeout=120.0,
+        )
+        response.raise_for_status()
+        result = response.json()
+    except httpx.ConnectError:
+        click.echo("Error: Cannot connect to Gobby daemon. Is it running?", err=True)
+        return
+    except httpx.HTTPStatusError as e:
+        click.echo(f"HTTP Error {e.response.status_code}: {e.response.text}", err=True)
+        return
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        return
+
+    if json_format:
+        click.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    if result.get("success"):
+        click.echo(f"Merged clone {clone_id} to {target_branch}")
+    else:
+        # Check for merge conflicts
+        if result.get("has_conflicts"):
+            conflicted = result.get("conflicted_files", [])
+            click.echo(f"Merge conflict in {len(conflicted)} file(s):", err=True)
+            for f in conflicted:
+                click.echo(f"  {f}", err=True)
+        else:
+            click.echo(f"Failed to merge clone: {result.get('error')}", err=True)
+
+
+@clones.command("delete")
+@click.argument("clone_ref")
+@click.option("--force", "-f", is_flag=True, help="Force delete even if active")
+@click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompt")
+@click.option("--json", "json_format", is_flag=True, help="Output as JSON")
+def delete_clone(clone_ref: str, force: bool, yes: bool, json_format: bool) -> None:
+    """Delete a clone.
+
+    Examples:
+
+        gobby clones delete clone-123 --yes
+
+        gobby clones delete clone-123 --force --yes
+    """
+    manager = get_clone_manager()
+    clone_id = resolve_clone_id(manager, clone_ref)
+
+    if not clone_id:
+        if json_format:
+            click.echo(json.dumps({"success": False, "error": f"Clone not found: {clone_ref}"}))
+        else:
+            click.echo(f"Clone not found: {clone_ref}", err=True)
+        return
+
+    if not yes and not json_format:
+        click.confirm("Are you sure you want to delete this clone?", abort=True)
+
+    daemon_url = get_daemon_url()
+
+    try:
+        response = httpx.post(
+            f"{daemon_url}/mcp/gobby-clones/tools/delete_clone",
+            json={"clone_id": clone_id, "force": force},
+            timeout=60.0,
+        )
+        response.raise_for_status()
+        result = response.json()
+    except httpx.ConnectError:
+        if json_format:
+            click.echo(json.dumps({"success": False, "error": "Cannot connect to Gobby daemon"}))
+        else:
+            click.echo("Error: Cannot connect to Gobby daemon. Is it running?", err=True)
+        return
+    except httpx.HTTPStatusError as e:
+        if json_format:
+            click.echo(
+                json.dumps(
+                    {
+                        "success": False,
+                        "error": f"HTTP Error {e.response.status_code}",
+                        "detail": e.response.text,
+                    }
+                )
+            )
+        else:
+            click.echo(f"HTTP Error {e.response.status_code}: {e.response.text}", err=True)
+        return
+    except Exception as e:
+        if json_format:
+            click.echo(json.dumps({"success": False, "error": str(e)}))
+        else:
+            click.echo(f"Error: {e}", err=True)
+        return
+
+    if json_format:
+        click.echo(json.dumps(result, indent=2, default=str))
+        return
+
+    if result.get("success"):
+        click.echo(f"Deleted clone: {clone_id}")
+    else:
+        click.echo(f"Failed to delete clone: {result.get('error')}", err=True)
+
+
+def resolve_clone_id(manager: LocalCloneManager, clone_ref: str) -> str | None:
+    """Resolve clone reference (UUID or prefix) to full ID."""
+    # Check for exact match first
+    if manager.get(clone_ref):
+        return clone_ref
+
+    # Try prefix match
+    all_clones = manager.list_clones()
+    matches = [c for c in all_clones if c.id.startswith(clone_ref)]
+
+    if not matches:
+        return None
+
+    if len(matches) > 1:
+        click.echo(f"Ambiguous clone reference '{clone_ref}' matches:", err=True)
+        for c in matches:
+            click.echo(f"  {c.id[:8]} ({c.branch_name})", err=True)
+        return None
+
+    return matches[0].id