devcouncil 0.2.0 → 0.2.1

package/src/devcouncil/execution/shell_session.py

@@ -1,225 +0,0 @@
-"""Guarded shell command session for DevCouncil tasks."""
-
-from __future__ import annotations
-
-import os
-import shlex
-import shutil
-import subprocess
-import uuid
-from pathlib import Path
-
-from rich.console import Console
-
-from devcouncil.domain.evidence import CommandResult
-from devcouncil.domain.task import Task
-from devcouncil.execution.checkpoints import CheckpointService
-from devcouncil.execution.hook_policy import HookPolicy
-from devcouncil.storage.db import get_db
-from devcouncil.storage.native import ShellCommandRepository, ShellSessionRepository, TaskLeaseRepository
-from devcouncil.storage.repositories import EvidenceRepository, TaskRepository
-from devcouncil.telemetry.traces import TraceLogger
-
-
-class ShellBackend:
-    def run_command(self, command: str, cwd: Path, env: dict[str, str] | None = None) -> subprocess.CompletedProcess[str]:
-        raise NotImplementedError
-
-
-class CommandLoopBackend(ShellBackend):
-    def run_command(self, command: str, cwd: Path, env: dict[str, str] | None = None) -> subprocess.CompletedProcess[str]:
-        args = shlex.split(command, posix=(os.name != "nt"))
-        return subprocess.run(
-            args,
-            cwd=cwd,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-            env=env,
-        )
-
-
-class ShellWrappedBackend(ShellBackend):
-    """Runs each command through an explicit shell (pwsh/bash/zsh/...)."""
-
-    _LAUNCHERS = {
-        "pwsh": ["pwsh", "-NoProfile", "-Command"],
-        "powershell": ["powershell", "-NoProfile", "-Command"],
-        "bash": ["bash", "-lc"],
-        "zsh": ["zsh", "-lc"],
-        "sh": ["sh", "-lc"],
-    }
-
-    def __init__(self, shell: str):
-        launcher = self._LAUNCHERS.get(shell)
-        if launcher is None:
-            supported = ", ".join(sorted(self._LAUNCHERS))
-            raise ValueError(f"Unknown shell backend '{shell}'. Use auto or one of: {supported}.")
-        if not shutil.which(launcher[0]):
-            raise ValueError(f"Shell '{launcher[0]}' is not installed or not on PATH.")
-        self.launcher = launcher
-
-    def run_command(self, command: str, cwd: Path, env: dict[str, str] | None = None) -> subprocess.CompletedProcess[str]:
-        return subprocess.run(
-            [*self.launcher, command],
-            cwd=cwd,
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-            env=env,
-        )
-
-
-_EVIDENCE_COMMAND_HINTS = ("pytest", "ruff", "mypy", "npm test", "npm run lint", "npm run typecheck")
-
-console = Console()
-
-
-class GuardedShellSession:
-    def __init__(self, project_root: Path, task: Task, *, shell: str = "auto"):
-        self.project_root = project_root.resolve()
-        self.task = task
-        self.shell = shell
-        # HookPolicy (not the bare TaskPolicyEngine) so a chained command is split into
-        # its segments and EACH is allowlisted, plus git-safety denies (force-push,
-        # --no-verify, protected-branch reset). Critical for the `--shell bash/zsh`
-        # backend, which hands the whole string to a real shell that interprets
-        # `;`/`&&`/`|` — a single whole-string allowlist match would let an allowed
-        # prefix smuggle an arbitrary command past the gate.
-        self.policy = HookPolicy(self.project_root)
-        self.backend: ShellBackend = (
-            CommandLoopBackend() if shell in {"auto", "loop"} else ShellWrappedBackend(shell)
-        )
-        self.lease_token: str | None = None
-        self.session_id: str | None = None
-        self.log_dir = self.project_root / ".devcouncil" / "logs"
-        self.log_dir.mkdir(parents=True, exist_ok=True)
-
-    def start(self, *, force: bool = False) -> None:
-        db = get_db(self.project_root)
-        if not db:
-            raise RuntimeError("DevCouncil not initialized.")
-        with db.get_session() as session:
-            lease = TaskLeaseRepository(session).acquire(
-                self.task.id,
-                owner="dev shell",
-                agent=self.shell,
-                force=force,
-            )
-            self.lease_token = lease.lease_token
-            shell_session = ShellSessionRepository(session).start(
-                self.task.id,
-                self.shell,
-                str(self.project_root),
-                lease_id=lease.id,
-            )
-            self.session_id = shell_session.id
-            self.task.status = "running"
-            TaskRepository(session).save(self.task)
-        CheckpointService(self.project_root).create_before(self.task.id)
-
-    def finish(self) -> None:
-        db = get_db(self.project_root)
-        if not db or not self.lease_token:
-            return
-        with db.get_session() as session:
-            if self.session_id:
-                ShellSessionRepository(session).finish(self.session_id, "finished")
-            TaskLeaseRepository(session).release(self.task.id, self.lease_token)
-
-    def run_one(self, command: str) -> int:
-        normalized = " ".join(command.split())
-        decision = self.policy.evaluate_command(normalized, self.task)
-        log_id = uuid.uuid4().hex[:8]
-        stdout_path = self.log_dir / f"{self.task.id}-{log_id}.stdout.log"
-        stderr_path = self.log_dir / f"{self.task.id}-{log_id}.stderr.log"
-
-        if decision.action == "deny":
-            self._record_command(normalized, "denied", reason=decision.reason)
-            TraceLogger(self.project_root).log_event(
-                "shell_command_denied",
-                {"command": normalized, "reason": decision.reason},
-                task_id=self.task.id,
-            )
-            # Tell the user *why* — a silent non-zero exit is unactionable.
-            console.print(
-                f"[red]Command denied for {self.task.id}:[/red] {decision.reason or 'not permitted by task policy.'}"
-            )
-            console.print(
-                "[dim]Add it to the task's allowed_commands, or run it outside DevCouncil.[/dim]"
-            )
-            return 1
-
-        try:
-            result = self.backend.run_command(normalized, self.project_root)
-        except (NotImplementedError, FileNotFoundError, OSError) as exc:
-            self._record_command(normalized, "denied", reason=str(exc))
-            console.print(f"[red]Could not run '{normalized}':[/red] {exc}")
-            return 1
-
-        stdout_path.write_text(result.stdout or "", encoding="utf-8")
-        stderr_path.write_text(result.stderr or "", encoding="utf-8")
-        # Echo the command output so the guarded shell is actually usable.
-        if result.stdout:
-            console.print(result.stdout, end="", markup=False, highlight=False)
-        if result.stderr:
-            console.print(result.stderr, end="", markup=False, highlight=False, style="dim")
-        status = "finished" if result.returncode == 0 else "failed"
-        self._record_command(
-            normalized,
-            status,
-            exit_code=result.returncode,
-            stdout_path=str(stdout_path),
-            stderr_path=str(stderr_path),
-        )
-        if any(hint in normalized for hint in _EVIDENCE_COMMAND_HINTS):
-            self._save_command_evidence(normalized, result.returncode, result.stdout or result.stderr or "")
-        TraceLogger(self.project_root).log_event(
-            "shell_command_finished",
-            {"command": normalized, "exit_code": result.returncode},
-            task_id=self.task.id,
-        )
-        return result.returncode
-
-    def _record_command(
-        self,
-        command: str,
-        status: str,
-        *,
-        exit_code: int | None = None,
-        reason: str = "",
-        stdout_path: str = "",
-        stderr_path: str = "",
-    ) -> None:
-        db = get_db(self.project_root)
-        if not db:
-            return
-        with db.get_session() as session:
-            ShellCommandRepository(session).record(
-                self.task.id,
-                command,
-                status,
-                session_id=self.session_id,
-                exit_code=exit_code,
-                reason=reason,
-                stdout_path=stdout_path,
-                stderr_path=stderr_path,
-            )
-
-    def _save_command_evidence(self, command: str, exit_code: int, summary: str) -> None:
-        db = get_db(self.project_root)
-        if not db:
-            return
-        with db.get_session() as session:
-            EvidenceRepository(session).save_command_result(
-                self.task.id,
-                CommandResult(
-                    command=command,
-                    exit_code=exit_code,
-                    stdout_path="",
-                    stderr_path="",
-                    summary=summary[:500],
-                ),
-            )

package/src/devcouncil/execution/task_runner.py

@@ -1,170 +0,0 @@
-import hashlib
-import os
-import subprocess
-import logging
-import re
-import shlex
-from pathlib import Path
-from typing import Literal, Optional
-from devcouncil.domain.task import Task
-from devcouncil.execution.permissions import PermissionManager
-from devcouncil.domain.evidence import CommandResult
-from devcouncil.app.errors import ExecutionError
-
-from devcouncil.execution.patch import PatchEngine
-from devcouncil.execution.paths import resolve_project_path
-from devcouncil.telemetry.traces import TraceLogger
-from devcouncil.utils.redaction import redact_string
-
-logger = logging.getLogger(__name__)
-
-class TaskRunner:
-    """Safely executes task actions while enforcing permission boundaries."""
-    
-    def __init__(self, project_root: Path, permission_manager: PermissionManager):
-        self.project_root = project_root
-        self.permissions = permission_manager
-        self.patch_engine = PatchEngine(project_root)
-
-    def _validate_path_within_root(self, path: str) -> None:
-        """Ensure a path resolves to a location within the project root."""
-        resolve_project_path(self.project_root, path)
-
-    def apply_patch(self, patch: str, task: Task) -> bool:
-        """Apply a patch if permissions allow (all affected files must be in planned_files)."""
-        changes = self._extract_patch_changes(patch)
-        for path, operation in changes.items():
-            self._validate_path_within_root(path)
-            self.permissions.validate_action("file_write", path, task, operation=operation)
-        applied = self.patch_engine.apply_patch(patch)
-        TraceLogger(self.project_root).log_event(
-            "tool_patch_applied",
-            {"paths": sorted(changes), "success": applied},
-            task_id=task.id,
-            summary=f"Patch {'applied' if applied else 'failed'} for {task.id}",
-        )
-        return applied
-
-    def _extract_patch_paths(self, patch: str) -> set[str]:
-        return set(self._extract_patch_changes(patch))
-
-    def _extract_patch_changes(self, patch: str) -> dict[str, Literal["create", "modify", "delete"]]:
-        """Extract repository-relative file paths touched by a unified git patch."""
-        changes: dict[str, Literal["create", "modify", "delete"]] = {}
-        old_path: Optional[str] = None
-        old_is_null = False
-        for line in patch.splitlines():
-            if line.startswith("diff --git "):
-                parts = line.split()
-                cleaned = self._normalize_patch_path(parts[3]) if len(parts) > 3 else None
-                if cleaned:
-                    changes.setdefault(cleaned, "modify")
-                old_path = self._normalize_patch_path(parts[2]) if len(parts) > 2 else None
-                old_is_null = False
-                continue
-
-            if line.startswith("--- "):
-                raw = line[4:].split("\t", 1)[0].strip()
-                old_is_null = raw == "/dev/null"
-                old_path = self._normalize_patch_path(raw)
-                continue
-
-            if line.startswith("+++ "):
-                raw = line[4:].split("\t", 1)[0].strip()
-                if raw == "/dev/null":
-                    if old_path:
-                        changes[old_path] = "delete"
-                    continue
-                new_path = self._normalize_patch_path(raw)
-                if new_path:
-                    changes[new_path] = "create" if old_is_null else "modify"
-
-        if not changes:
-            raise ExecutionError("Patch does not declare any affected files.")
-        return changes
-
-    def _normalize_patch_path(self, raw_path: str) -> Optional[str]:
-        raw_path = raw_path.strip().strip('"')
-        if raw_path == "/dev/null":
-            return None
-        raw_path = re.sub(r"^[ab]/", "", raw_path)
-        return raw_path.replace("\\", "/")
-
-    def _save_command_log(self, task_id: str, command: str, stream: str, content: str) -> str:
-        """Save command output to a log file and return the path."""
-        log_dir = self.project_root / ".devcouncil" / "logs"
-        log_dir.mkdir(parents=True, exist_ok=True)
-        cmd_hash = hashlib.sha256(command.encode()).hexdigest()[:8]
-        filename = f"{task_id}-{cmd_hash}-{stream}.log"
-        log_path = log_dir / filename
-        log_path.write_text(redact_string(content), encoding="utf-8")
-        return str(log_path)
-
-    def run_command(self, command: str, task: Task) -> CommandResult:
-        """Execute a shell command if allowed by permissions."""
-        self.permissions.validate_action("shell", command, task)
-        
-        logger.info(f"Executing authorized command: {command}")
-        
-        try:
-            from devcouncil.app.config import load_config
-            config = load_config(self.project_root)
-            timeout = config.execution.command_timeout
-        except Exception:
-            timeout = 300
-
-        try:
-            result = subprocess.run(
-                # POSIX-correct tokenization on POSIX hosts (so quoted args like
-                # `pytest -k "a and b"` split right and match the allowlist), Windows
-                # rules on Windows. Matches shell_session.py.
-                shlex.split(command, posix=(os.name != "nt")),
-                shell=False,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-                errors="replace",
-                cwd=self.project_root,
-                timeout=timeout
-            )
-            stdout = result.stdout or ""
-            stderr = result.stderr or ""
-            stdout_path = self._save_command_log(task.id, command, "stdout", stdout)
-            stderr_path = self._save_command_log(task.id, command, "stderr", stderr)
-            stdout_summary = redact_string(stdout[-500:])
-            stderr_summary = redact_string(stderr[-500:])
-            TraceLogger(self.project_root).log_event(
-                "command_executed",
-                {"command": command, "exit_code": result.returncode},
-                task_id=task.id,
-                summary=f"{command} exited {result.returncode}",
-            )
-            return CommandResult(
-                command=command,
-                exit_code=result.returncode,
-                stdout_path=stdout_path,
-                stderr_path=stderr_path,
-                summary=f"Exit code {result.returncode}. stdout: {stdout_summary}. stderr: {stderr_summary}"
-            )
-        except Exception as e:
-            raise ExecutionError(f"Command execution failed: {e}")
-
-    def write_file(self, path: str, content: str, task: Task):
-        """Write content to a file if allowed by permissions."""
-        self._validate_path_within_root(path)
-        full_path = resolve_project_path(self.project_root, path)
-        operation: Literal["create", "modify"] = "modify" if full_path.exists() else "create"
-        self.permissions.validate_action("file_write", path, task, operation=operation)
-
-        logger.info(f"Writing authorized file: {path}")
-        try:
-            full_path.parent.mkdir(parents=True, exist_ok=True)
-            full_path.write_text(content, encoding="utf-8")
-            TraceLogger(self.project_root).log_event(
-                "file_written",
-                {"path": path},
-                task_id=task.id,
-                summary=f"Wrote {path}",
-            )
-        except Exception as e:
-            raise ExecutionError(f"Failed to write file {path}: {e}")

package/src/devcouncil/executors/__init__.py

@@ -1 +0,0 @@
-