mindcode 0.2.0__py3-none-any.whl

mindcode/subagents.py

@@ -0,0 +1,43 @@
+"""MindCode ownership boundary for orchestrated master/worker runs."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from mindagent.core import (
+    AgentOrchestrator,
+    AgentTaskResult,
+    CloseReport,
+    SessionEnvironment,
+    SessionPolicy,
+)
+
+
+@dataclass
+class MasterWorkerSystem:
+    """Run MindCode's registered master and close its owned workers."""
+
+    orchestrator: AgentOrchestrator
+    master_agent_id: str = "master"
+
+    async def run(
+        self,
+        user_input: str,
+        *,
+        task_id: str | None = None,
+        session_environment: SessionEnvironment | None = None,
+        session_policy: SessionPolicy | None = None,
+        messages: list[dict[str, Any]] | None = None,
+    ) -> AgentTaskResult:
+        return await self.orchestrator.run_agent(
+            self.master_agent_id,
+            user_input,
+            task_id=task_id,
+            session_environment=session_environment,
+            session_policy=session_policy,
+            messages=messages,
+        )
+
+    async def close(self) -> CloseReport:
+        return await self.orchestrator.close(close_workers=True)

mindcode/tasking.py

@@ -0,0 +1,281 @@
+from __future__ import annotations
+
+import json
+import os
+import re
+import time
+import uuid
+from dataclasses import asdict, dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+from mindagent.core import AgentEvent, LocalTaskMemoryStore
+from mindagent.core.artifact import (
+    ensure_artifact_directory,
+    open_artifact_text,
+    read_artifact_text,
+    validate_artifact_path,
+)
+
+from .config import CONFIG_DIR
+
+
+TASKS_DIR = CONFIG_DIR / "tasks"
+_TASK_ID_PATTERN = re.compile(r"^[A-Za-z0-9._-]+$")
+
+
+class TaskStatus(str, Enum):
+    CREATED = "created"
+    RUNNING = "running"
+    PARTIAL = "partial"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+@dataclass
+class TaskRecord:
+    task_id: str
+    status: str
+    goal: str
+    workspace: str
+    provider: str
+    model: str | None
+    approve_mode: str
+    created_at: float
+    started_at: float | None = None
+    completed_at: float | None = None
+    run_id: str | None = None
+    final_answer: str | None = None
+    error: str | None = None
+    metrics: dict[str, Any] = field(default_factory=dict)
+    pid: int | None = None
+    background: bool = False
+    max_steps: int = 50
+    total_timeout_s: float | None = 1800.0
+    allow_dangerous: bool = False
+
+
+class TaskStore:
+    def __init__(self, root: Path = TASKS_DIR):
+        root_path = Path(root).expanduser()
+        ensure_artifact_directory(root_path)
+        self.root = root_path.resolve()
+
+    def task_dir(self, task_id: str) -> Path:
+        task_id = _canonical_task_id(task_id)
+        path = self.root / task_id
+        validate_artifact_path(self.root, path)
+        return path
+
+    def _task_file(self, task_id: str, filename: str) -> Path:
+        path = self.task_dir(task_id) / filename
+        validate_artifact_path(self.root, path)
+        return path
+
+    def _write_text(self, path: Path, text: str) -> None:
+        validate_artifact_path(self.root, path)
+        temporary = path.with_name(f".{path.name}.{uuid.uuid4().hex}.tmp")
+        try:
+            with open_artifact_text(temporary, root=self.root) as file:
+                file.write(text)
+                file.flush()
+                os.fsync(file.fileno())
+            validate_artifact_path(self.root, path)
+            os.replace(temporary, path)
+        finally:
+            try:
+                temporary.unlink()
+            except FileNotFoundError:
+                pass
+
+    def create(
+        self,
+        *,
+        goal: str,
+        workspace: Path,
+        provider: str,
+        model: str | None,
+        approve_mode: str,
+        background: bool = False,
+        max_steps: int = 50,
+        total_timeout_s: float | None = 1800.0,
+        allow_dangerous: bool = False,
+    ) -> TaskRecord:
+        now = time.time()
+        task_id = (
+            time.strftime("task-%Y%m%d-%H%M%S", time.localtime(now))
+            + f"-{int(now * 1000) % 1000:03d}"
+        )
+        record = TaskRecord(
+            task_id=task_id,
+            status=TaskStatus.CREATED.value,
+            goal=goal,
+            workspace=str(workspace),
+            provider=provider,
+            model=model,
+            approve_mode=approve_mode,
+            created_at=now,
+            background=background,
+            max_steps=max_steps,
+            total_timeout_s=total_timeout_s,
+            allow_dangerous=allow_dangerous,
+        )
+        self.save(record)
+        return record
+
+    def save(self, record: TaskRecord) -> None:
+        if not isinstance(record, TaskRecord):
+            raise ValueError("record 必须是 TaskRecord")
+        record.task_id = _canonical_task_id(record.task_id)
+        if record.run_id is not None:
+            record.run_id = _canonical_record_text(
+                record.run_id,
+                "run_id",
+                require_nonempty=True,
+            )
+        path = self.task_dir(record.task_id)
+        ensure_artifact_directory(path, root=self.root)
+        self._write_text(
+            self._task_file(record.task_id, "task.json"),
+            json.dumps(asdict(record), ensure_ascii=False, indent=2),
+        )
+
+    def load(self, task_id: str) -> TaskRecord:
+        task_id_text = _canonical_task_id(task_id)
+        path = self._task_file(task_id_text, "task.json")
+        data = json.loads(read_artifact_text(path, root=self.root))
+        if not isinstance(data, dict):
+            raise ValueError("task payload 必须是对象")
+        record = TaskRecord(**data)
+        if _canonical_task_id(record.task_id) != task_id_text:
+            raise ValueError("task task_id 不匹配")
+        record.task_id = task_id_text
+        return record
+
+    def list(self) -> list[TaskRecord]:
+        validate_artifact_path(self.root, self.root)
+        if not self.root.exists():
+            return []
+        records: list[TaskRecord] = []
+        for path in sorted(self.root.iterdir(), reverse=True):
+            if path.is_symlink() or not path.is_dir():
+                continue
+            try:
+                task_path = self._task_file(path.name, "task.json")
+            except (OSError, RuntimeError, ValueError):
+                continue
+            if not task_path.exists():
+                continue
+            try:
+                record = TaskRecord(
+                    **json.loads(read_artifact_text(task_path, root=self.root))
+                )
+                if _canonical_task_id(record.task_id) != path.name:
+                    continue
+                record.task_id = path.name
+                records.append(self.refresh(record))
+            except Exception:
+                continue
+        return records
+
+    def refresh(self, record: TaskRecord) -> TaskRecord:
+        if (
+            record.status == TaskStatus.RUNNING.value
+            and record.pid is not None
+            and not is_process_alive(record.pid)
+        ):
+            record.status = TaskStatus.FAILED.value
+            record.completed_at = time.time()
+            record.error = "background process exited without finalizing task"
+            self.save(record)
+            self.write_summary(record)
+        return record
+
+    def write_summary(self, record: TaskRecord) -> None:
+        metrics = "\n".join(
+            f"- {key}: {value}" for key, value in sorted(record.metrics.items())
+        )
+        text = (
+            f"# {record.task_id}\n\n"
+            f"Status: {record.status}\n"
+            f"Goal: {record.goal}\n"
+            f"Workspace: {record.workspace}\n\n"
+            "## Result\n\n"
+            f"{record.final_answer or record.error or ''}\n\n"
+            "## Metrics\n\n"
+            f"{metrics}\n"
+        )
+        path = self.task_dir(record.task_id)
+        ensure_artifact_directory(path, root=self.root)
+        self._write_text(
+            self._task_file(record.task_id, "summary.md"),
+            text,
+        )
+
+
+class TaskEventRecorder:
+    def __init__(self, store: TaskStore, task_id: str):
+        self.memory_store = LocalTaskMemoryStore(
+            store.task_dir(task_id)
+        )
+        self.agent_events = 0
+        self.tool_calls = 0
+
+    async def __call__(self, event: AgentEvent) -> None:
+        self.agent_events += 1
+        if event.event_type.value == "action_started":
+            self.tool_calls += 1
+        await self.memory_store.append_event(event)
+
+
+def is_process_alive(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    return True
+
+
+def _canonical_task_id(task_id: Any) -> str:
+    if not isinstance(task_id, str):
+        raise ValueError(
+            "task_id 只能包含字母、数字、点、下划线和连字符"
+        )
+    try:
+        value = str.__str__(task_id)
+        length = str.__len__(value)
+    except BaseException as exc:
+        raise ValueError("task_id 无法解析") from exc
+    if (
+        type(value) is not str
+        or length == 0
+        or value in {".", ".."}
+        or _TASK_ID_PATTERN.fullmatch(value) is None
+    ):
+        raise ValueError(
+            "task_id 只能包含字母、数字、点、下划线和连字符"
+        )
+    return value
+
+
+def _canonical_record_text(
+    value: Any,
+    name: str,
+    *,
+    require_nonempty: bool = False,
+) -> str:
+    if not isinstance(value, str):
+        raise ValueError(f"{name} 必须是字符串")
+    try:
+        normalized = str.__str__(value)
+    except BaseException as exc:
+        raise ValueError(f"{name} 无法解析") from exc
+    if type(normalized) is not str:
+        raise ValueError(f"{name} 必须是字符串")
+    if require_nonempty and str.__len__(normalized) == 0:
+        raise ValueError(f"{name} 必须是非空字符串")
+    return normalized

mindcode/terminal/__init__.py

@@ -0,0 +1 @@
+"""Terminal worker package."""

mindcode/terminal/__main__.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from ..terminal_core import run_worker
+
+
+def main() -> int:
+    if len(sys.argv) != 4 or sys.argv[1] != "_worker":
+        print("usage: python -m mindcode.terminal _worker <terminal_id> <root>")
+        return 2
+    return run_worker(sys.argv[2], Path(sys.argv[3]))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mindcode/terminal_core.py

@@ -0,0 +1,264 @@
+from __future__ import annotations
+
+import json
+import os
+import pty
+import errno
+import select
+import signal
+import subprocess
+import sys
+import time
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from .config import CONFIG_DIR
+from .tasking import is_process_alive
+
+
+TERMINALS_DIR = CONFIG_DIR / "terminals"
+
+
+@dataclass
+class TerminalRecord:
+    terminal_id: str
+    status: str
+    cwd: str
+    shell: str
+    pid: int | None
+    created_at: float
+    updated_at: float
+
+
+class TerminalStore:
+    def __init__(self, root: Path = TERMINALS_DIR):
+        self.root = root
+
+    def terminal_dir(self, terminal_id: str) -> Path:
+        return self.root / terminal_id
+
+    def create_record(self, *, cwd: Path, shell: str) -> TerminalRecord:
+        now = time.time()
+        terminal_id = (
+            time.strftime("term-%Y%m%d-%H%M%S", time.localtime(now))
+            + f"-{int(now * 1000) % 1000:03d}"
+        )
+        record = TerminalRecord(
+            terminal_id=terminal_id,
+            status="created",
+            cwd=str(cwd),
+            shell=shell,
+            pid=None,
+            created_at=now,
+            updated_at=now,
+        )
+        self.save(record)
+        return record
+
+    def save(self, record: TerminalRecord) -> None:
+        path = self.terminal_dir(record.terminal_id)
+        path.mkdir(parents=True, exist_ok=True)
+        record.updated_at = time.time()
+        (path / "terminal.json").write_text(
+            json.dumps(asdict(record), ensure_ascii=False, indent=2),
+            encoding="utf-8",
+        )
+
+    def load(self, terminal_id: str) -> TerminalRecord:
+        data = json.loads(
+            (self.terminal_dir(terminal_id) / "terminal.json").read_text(
+                encoding="utf-8"
+            )
+        )
+        return TerminalRecord(**data)
+
+    def list(self) -> list[TerminalRecord]:
+        if not self.root.exists():
+            return []
+        records: list[TerminalRecord] = []
+        for path in sorted(self.root.iterdir(), reverse=True):
+            record_path = path / "terminal.json"
+            if not record_path.exists():
+                continue
+            try:
+                records.append(self.refresh(TerminalRecord(**json.loads(record_path.read_text()))))
+            except Exception:
+                continue
+        return records
+
+    def refresh(self, record: TerminalRecord) -> TerminalRecord:
+        if record.status == "running" and record.pid is not None:
+            if not is_process_alive(record.pid):
+                record.status = "exited"
+                self.save(record)
+        return record
+
+    def log_path(self, terminal_id: str) -> Path:
+        return self.terminal_dir(terminal_id) / "terminal.log"
+
+
+class TerminalManager:
+    def __init__(self, store: TerminalStore | None = None):
+        self.store = store or TerminalStore()
+
+    def start(
+        self,
+        *,
+        cwd: Path,
+        shell: str | None = None,
+    ) -> TerminalRecord:
+        cwd = cwd.expanduser().resolve()
+        if not cwd.is_dir():
+            raise ValueError(f"cwd 不存在或不是目录: {cwd}")
+        shell_path = shell or os.environ.get("SHELL") or "/bin/bash"
+        record = self.store.create_record(cwd=cwd, shell=shell_path)
+        term_dir = self.store.terminal_dir(record.terminal_id)
+        input_path = term_dir / "input.fifo"
+        os.mkfifo(input_path)
+
+        cmd = [
+            sys.executable,
+            "-m",
+            "mindcode.terminal",
+            "_worker",
+            record.terminal_id,
+            str(self.store.root),
+        ]
+        env = os.environ.copy()
+        here = Path(__file__).resolve()
+        source_paths = [str(here.parents[1])]
+        repo_src = here.parents[3] / "src"
+        if repo_src.is_dir():
+            source_paths.append(str(repo_src))
+        env["PYTHONPATH"] = (
+            os.pathsep.join(source_paths)
+            if not env.get("PYTHONPATH")
+            else os.pathsep.join(source_paths) + os.pathsep + env["PYTHONPATH"]
+        )
+        log_path = term_dir / "worker.log"
+        with log_path.open("ab") as log:
+            process = subprocess.Popen(
+                cmd,
+                stdout=log,
+                stderr=subprocess.STDOUT,
+                cwd=cwd,
+                env=env,
+                start_new_session=True,
+            )
+        record.pid = process.pid
+        record.status = "running"
+        self.store.save(record)
+        return record
+
+    def send(self, terminal_id: str, text: str, *, newline: bool = True) -> None:
+        record = self.store.refresh(self.store.load(terminal_id))
+        if record.status != "running":
+            raise RuntimeError(f"terminal 当前不是 running: {record.status}")
+        payload = text + ("\n" if newline else "")
+        fifo_path = self.store.terminal_dir(terminal_id) / "input.fifo"
+        deadline = time.time() + 5
+        while True:
+            try:
+                fd = os.open(fifo_path, os.O_WRONLY | os.O_NONBLOCK)
+                break
+            except OSError as exc:
+                if exc.errno != errno.ENXIO or time.time() >= deadline:
+                    worker_log = self.store.terminal_dir(terminal_id) / "worker.log"
+                    detail = ""
+                    if worker_log.exists():
+                        detail = worker_log.read_text(
+                            encoding="utf-8",
+                            errors="replace",
+                        )[-1000:]
+                    raise RuntimeError(
+                        f"terminal worker 未就绪: {detail}"
+                    ) from exc
+                time.sleep(0.1)
+        with os.fdopen(fd, "w", encoding="utf-8") as fifo:
+            fifo.write(payload)
+
+    def close(self, terminal_id: str) -> TerminalRecord:
+        record = self.store.refresh(self.store.load(terminal_id))
+        if record.status == "running" and record.pid is not None:
+            try:
+                os.killpg(record.pid, signal.SIGTERM)
+            except ProcessLookupError:
+                pass
+            except PermissionError:
+                try:
+                    os.kill(record.pid, signal.SIGTERM)
+                except ProcessLookupError:
+                    pass
+        record.status = "closed"
+        self.store.save(record)
+        return record
+
+
+def run_worker(terminal_id: str, root: Path) -> int:
+    store = TerminalStore(root)
+    record = store.load(terminal_id)
+    term_dir = store.terminal_dir(terminal_id)
+    input_path = term_dir / "input.fifo"
+    log_path = store.log_path(terminal_id)
+
+    pid, fd = pty.fork()
+    if pid == 0:
+        os.chdir(record.cwd)
+        os.execv(record.shell, [record.shell])
+
+    with log_path.open("ab", buffering=0) as log:
+        fifo_fd = os.open(input_path, os.O_RDWR | os.O_NONBLOCK)
+        try:
+            while True:
+                ready, _, _ = select.select([fd, fifo_fd], [], [], 0.2)
+                if fd in ready:
+                    try:
+                        data = os.read(fd, 4096)
+                    except OSError:
+                        break
+                    if not data:
+                        break
+                    log.write(data)
+                if fifo_fd in ready:
+                    data = os.read(fifo_fd, 4096)
+                    if data:
+                        os.write(fd, data)
+                try:
+                    finished, status = os.waitpid(pid, os.WNOHANG)
+                except ChildProcessError:
+                    break
+                if finished == pid:
+                    break
+        finally:
+            os.close(fifo_fd)
+            os.close(fd)
+
+    record = store.load(terminal_id)
+    if record.status == "running":
+        record.status = "exited"
+        store.save(record)
+    return 0
+
+
+def tail_text(path: Path, lines: int) -> str:
+    if not path.exists():
+        return ""
+    content = path.read_text(encoding="utf-8", errors="replace")
+    return "\n".join(content.splitlines()[-lines:])
+
+
+def build_ghostty_open_argv(
+    *,
+    cwd: Path,
+    command: str | None = None,
+    app_path: str = "/Applications/Ghostty.app",
+) -> list[str]:
+    argv = [
+        "open",
+        "-na",
+        app_path,
+        "--args",
+        f"--working-directory={cwd.expanduser().resolve()}",
+    ]
+    if command:
+        argv.extend(["-e", command])
+    return argv