mosscode 0.1.0__py3-none-any.whl

mosscode/hooks/engine.py

@@ -0,0 +1,401 @@
+"""Match hooks to an event, run them in order, log and report."""
+
+import asyncio
+import json
+import sys
+import time
+from collections import deque
+from collections.abc import Awaitable, Callable, Mapping
+from dataclasses import dataclass, field, replace
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from .actions import ActionResult, public_url, render, run_command, run_http, short, stdin_json
+from .config import Hook, HookConfig, HookFile, TrustStore, load_hooks
+from .events import EVENTS
+
+FILE_TOOLS = {"read_file", "write_file", "edit_file", "glob", "grep"}
+RESULT_LIMIT = 64 * 1024
+RECENT = 50
+
+
+@dataclass(frozen=True)
+class HookEvent:
+    name: str
+    agent: str = "main"
+    fields: Mapping[str, str] = field(default_factory=dict)  # Condition fields, as strings.
+    payload: Mapping[str, Any] = field(default_factory=dict)  # The rest of the stdin JSON (args, result ...).
+    file_path: Path | None = None  # MOSSCODE_FILE_PATH / ${FILE_PATH}
+    tool: str = ""
+    agent_type: str = ""  # "" in the main conversation, the definition name, "fork" or "skill:<name>".
+    nested: bool = False  # A tool event of a sub-agent started by an agent action.
+
+
+@dataclass(frozen=True)
+class HookOutcome:
+    rejection: tuple[str, str] | None = None  # (hook id, message for the model)
+    notes: tuple[tuple[str, str], ...] = ()  # (hook id, injected text)
+    ran: tuple[str, ...] = ()  # Synchronous hooks that ran, in order.
+
+
+NOTHING = HookOutcome()
+
+
+@dataclass(frozen=True)
+class HookRun:
+    time: str
+    hook: str
+    source: str
+    event: str
+    agent: str
+    action: str
+    outcome: str
+    duration_ms: int
+    exit_code: int | None = None
+    status: int | None = None
+    detail: str = ""
+
+    def record(self) -> dict:
+        entry = {key: value for key, value in self.__dict__.items() if value is not None}
+        return entry
+
+
+def _canonical(value) -> str:
+    if isinstance(value, str):
+        return value
+    return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False, default=str)
+
+
+def tool_event(
+    name: str,
+    agent: str,
+    tool: str,
+    args: Mapping[str, Any],
+    operation,
+    root: Path,
+    result=None,
+    *,
+    agent_type: str = "",
+) -> HookEvent:
+    """Fields of the tool events: path and command are what the permission rules see."""
+    args = args if isinstance(args, Mapping) else {}
+    path = command = ""
+    file_path = None
+    if operation is not None and tool in FILE_TOOLS:
+        path = operation.target
+        file_path = Path(path) if operation.outside else root / path
+    elif operation is not None and tool == "execute_command":
+        command = operation.target
+    fields = {
+        "tool": tool,
+        "path": path,
+        "command": command,
+        **{f"args.{key}": _canonical(value) for key, value in args.items()},
+    }
+    payload = {"tool": tool, "args": dict(args), "path": path, "command": command}
+    if name == "permission_request" and operation is not None:
+        fields["risk"] = operation.risk
+    if result is not None:
+        fields["error"] = "true" if result.is_error else "false"
+        fields["code"] = result.code or ""
+        content = result.output.encode("utf-8")[:RESULT_LIMIT].decode("utf-8", errors="ignore")
+        payload["result"] = {"content": content, "is_error": result.is_error, "code": result.code}
+    return HookEvent(name, agent, fields, payload, file_path, tool, agent_type)
+
+
+class HookEngine:
+    def __init__(
+        self,
+        root: Path,
+        *,
+        home: Path | None = None,
+        shell=None,
+        enabled: bool = True,
+        trust_project: bool = False,
+        config: HookConfig | None = None,
+    ):
+        self.root = Path(root).resolve()
+        self.home = home
+        self.shell = shell
+        self.enabled = enabled
+        self.trust_project = trust_project
+        self.store = TrustStore(self.root, home)
+        self.config = (
+            config
+            if config is not None
+            else (
+                load_hooks(self.root, home, store=self.store, trust_project=trust_project) if enabled else HookConfig()
+            )
+        )
+        self.declined: set[Path] = set()  # Files the user chose not to enable this run.
+        self.recent: deque[HookRun] = deque(maxlen=RECENT)
+        self.session = None
+        self.session_id = ""
+        self.on_notice: Callable[[str], None] | None = None
+        self.notices: list[str] = []  # When nobody listens yet.
+        # Runs an agent action; set by the Conversation.
+        self.agent_runner: Callable[[Hook, HookEvent, Mapping[str, str]], Awaitable[ActionResult]] | None = None
+        self._once: set[str] = set()
+        self._noticed: set[str] = set()  # Per turn.
+        self._agent_noticed: set[str] = set()  # Per session.
+        self._background: set[asyncio.Task] = set()
+
+    # Configuration ---------------------------------------------------------------------------
+
+    @property
+    def hooks(self) -> tuple[Hook, ...]:
+        return self.config.hooks if self.enabled else ()
+
+    @property
+    def problems(self) -> tuple[str, ...]:
+        return self.config.problems
+
+    @property
+    def untrusted(self) -> tuple[HookFile, ...]:
+        return self.config.untrusted
+
+    def pending_trust(self) -> tuple[HookFile, ...]:
+        """Untrusted files the user has not declined during this run."""
+        return tuple(file for file in self.untrusted if file.path not in self.declined)
+
+    def wants(self, event: str) -> bool:
+        return any(hook.event == event for hook in self.hooks)
+
+    def trust(self, file: HookFile) -> None:
+        if file.digest is not None:
+            self.store.trust(file.path.name, file.digest)
+        self.declined.discard(file.path)
+        self.config = replace(
+            self.config, files=tuple(replace(f, trusted=True) if f.path == file.path else f for f in self.config.files)
+        )
+
+    def decline(self, file: HookFile) -> None:
+        self.declined.add(file.path)
+
+    def reload(self) -> tuple[list[str], list[str]]:
+        """Reread the files; once state is kept by id. Returns (added, removed) ids."""
+        before = {hook.id for hook in self.hooks}
+        self.declined.clear()
+        self.config = (
+            load_hooks(self.root, self.home, store=self.store, trust_project=self.trust_project)
+            if self.enabled
+            else HookConfig()
+        )
+        after = {hook.id for hook in self.hooks}
+        return sorted(after - before), sorted(before - after)
+
+    def find(self, hook_id: str) -> Hook | None:
+        return next((hook for file in self.config.files for hook in file.hooks if hook.id == hook_id), None)
+
+    def status(self, hook: Hook) -> str:
+        file = next((f for f in self.config.files if f.path == hook.path), None)
+        if file is not None and not file.trusted:
+            return "未确认"
+        if hook.once and hook.id in self._once:
+            return "once 已执行"
+        return "已启用"
+
+    # Sessions and turns -----------------------------------------------------------------------
+
+    def use_session(self, session) -> None:
+        self.session = session
+        self.session_id = getattr(session, "id", "") or ""
+
+    def new_session(self, session=None) -> None:
+        """Once resets with every new session (/clear, resume)."""
+        self._once.clear()
+        self._agent_noticed.clear()
+        if session is not None:
+            self.use_session(session)
+
+    def begin_turn(self) -> None:
+        self._noticed.clear()
+
+    @property
+    def log_path(self) -> Path | None:
+        return self.session.directory / "hooks.log" if self.session is not None else None
+
+    # Running ---------------------------------------------------------------------------------
+
+    async def fire(self, event: HookEvent) -> HookOutcome:
+        """Run the matching hooks in order. Never raises, except CancelledError."""
+        if not self.enabled:
+            return NOTHING
+        # subagent_start/stop carry the sub-agent's own agent_type in their fields.
+        fields = {"agent_type": event.agent_type, **event.fields, "event": event.name, "agent": event.agent}
+        notes, ran = [], []
+        for hook in self.hooks:
+            if hook.event != event.name or (hook.condition is not None and not hook.condition.matches(fields)):
+                continue
+            if hook.once:
+                if hook.id in self._once:
+                    continue
+                self._once.add(hook.id)  # Consumed when it starts, also if it fails.
+            if hook.background:
+                self.spawn(self._run(hook, event, fields))
+                continue
+            if hook.action is None:  # Static rejection without an action.
+                self._log(hook, event, "reject", ActionResult("rejected", short(hook.reject)), 0)
+                return HookOutcome(
+                    (hook.id, f"Hook {hook.id} 拒绝了此调用：{hook.reject}"), tuple(notes), (*ran, hook.id)
+                )
+            blocking = hook.reject is None and hook.on_error == "block"
+            result = await self._run(hook, event, fields, quiet=blocking)
+            ran.append(hook.id)
+            if hook.reject is not None:
+                return HookOutcome((hook.id, f"Hook {hook.id} 拒绝了此调用：{hook.reject}"), tuple(notes), tuple(ran))
+            if result.outcome == "rejected":
+                return HookOutcome((hook.id, f"Hook {hook.id} 拒绝了此调用：{result.reason}"), tuple(notes), tuple(ran))
+            if result.outcome in {"failed", "timeout"} and blocking:
+                return HookOutcome(
+                    (hook.id, f"Hook {hook.id} 执行失败，按配置阻止此调用：{result.detail}"), tuple(notes), tuple(ran)
+                )
+            if result.outcome == "ok" and result.output:
+                notes.append((hook.id, result.output))
+        return HookOutcome(None, tuple(notes), tuple(ran))
+
+    def spawn(self, coroutine) -> asyncio.Task:
+        task = asyncio.get_running_loop().create_task(coroutine)
+        self._background.add(task)
+        task.add_done_callback(self._settled)
+        return task
+
+    def _settled(self, task: asyncio.Task) -> None:
+        self._background.discard(task)
+        if not task.cancelled():
+            task.exception()  # Retrieved; _run never raises anything else.
+
+    async def drain(self, timeout: float) -> None:
+        """Wait for background hooks, then cancel the rest (their process trees are killed)."""
+        pending = set(self._background)
+        if not pending:
+            return
+        _, late = await asyncio.wait(pending, timeout=timeout)
+        for task in late:
+            task.cancel()
+        if late:
+            await asyncio.gather(*late, return_exceptions=True)
+
+    def _context(self, hook: Hook, event: HookEvent, fields) -> dict:
+        context = {
+            "event": event.name,
+            "hook_id": hook.id,
+            "session_id": self.session_id,
+            "project_root": str(self.root),
+            "agent": event.agent,
+        }
+        context.update({key: value for key, value in fields.items() if not key.startswith("args.")})
+        context.update(event.payload)
+        return context
+
+    def _env(self, hook: Hook, event: HookEvent) -> dict[str, str]:
+        env = {
+            "MOSSCODE_HOOK_ID": hook.id,
+            "MOSSCODE_HOOK_EVENT": event.name,
+            "MOSSCODE_SESSION_ID": self.session_id,
+            "MOSSCODE_PROJECT_ROOT": str(self.root),
+            "MOSSCODE_AGENT": event.agent,
+            "MOSSCODE_AGENT_TYPE": event.fields.get("agent_type", event.agent_type),
+            "PYTHONUTF8": "1",
+            "PYTHONIOENCODING": "utf-8",
+        }
+        if EVENTS[event.name].tool:
+            env["MOSSCODE_TOOL_NAME"] = event.tool
+            env["MOSSCODE_FILE_PATH"] = str(event.file_path) if event.file_path is not None else ""
+        return env
+
+    async def _execute(self, hook: Hook, event: HookEvent, fields) -> ActionResult:
+        action = hook.action
+        if action.type == "prompt":
+            return ActionResult("ok", output=render(action.message, fields).strip()[:8000])
+        if action.type == "agent":
+            if event.nested:  # No sub-agent starts another one.
+                return ActionResult("skipped", "由 Hook 启动的子 Agent 中不再运行 agent 动作")
+            if self.agent_runner is None:
+                return ActionResult("skipped", "当前运行方式不支持子 Agent")
+            return await self.agent_runner(hook, event, fields)
+        context = self._context(hook, event, fields)
+        if action.type == "http":
+            return await run_http(action, fields=fields, context=context)
+        values = {
+            "FILE_PATH": str(event.file_path) if event.file_path is not None else "",
+            "PROJECT_ROOT": str(self.root),
+            "PYTHON": sys.executable,
+            "TOOL_NAME": event.tool,
+            "EVENT": event.name,
+        }
+        return await run_command(
+            action,
+            root=self.root,
+            shell=self.shell,
+            env=self._env(hook, event),
+            values=values,
+            stdin=stdin_json(context),
+            rejecting=event.name == "pre_tool_use",
+        )
+
+    async def _run(self, hook: Hook, event: HookEvent, fields, *, quiet: bool = False) -> ActionResult:
+        started = time.monotonic()
+        try:
+            result = await self._execute(hook, event, fields)
+        except asyncio.CancelledError:
+            self._log(hook, event, hook.action.type, ActionResult("cancelled", "已取消"), started)
+            raise
+        except Exception as exc:  # A hook must never break the main flow.
+            result = ActionResult("failed", f"内部错误：{type(exc).__name__}")
+        self._log(hook, event, hook.action.type, result, started)
+        if result.outcome in {"failed", "timeout"} and not quiet:
+            self._notify(hook, f"Hook {hook.id}（{event.name}）失败：{result.detail.rstrip('。')}；已忽略。")
+        elif result.outcome == "skipped" and hook.id not in self._agent_noticed:
+            self._agent_noticed.add(hook.id)
+            self._emit(f"Hook {hook.id}（{event.name}）的子 Agent 动作已跳过：{result.detail}。")
+        return result
+
+    def _notify(self, hook: Hook, text: str) -> None:
+        if hook.id in self._noticed:
+            return
+        self._noticed.add(hook.id)
+        self._emit(text)
+
+    def _emit(self, text: str) -> None:
+        if self.on_notice is not None:
+            try:
+                self.on_notice(text)
+                return
+            except Exception:
+                pass
+        self.notices.append(text)
+
+    def take_notices(self) -> list[str]:
+        notices, self.notices = self.notices, []
+        return notices
+
+    def _log(self, hook: Hook, event: HookEvent, action: str, result: ActionResult, started: float) -> None:
+        duration = int((time.monotonic() - started) * 1000) if started else 0
+        detail = result.detail
+        if hook.action is not None and hook.action.type == "http":
+            detail = detail.replace(hook.action.url, public_url(hook.action.url))
+        run = HookRun(
+            datetime.now().astimezone().isoformat(timespec="milliseconds"),
+            hook.id,
+            hook.source,
+            event.name,
+            event.agent,
+            action,
+            result.outcome,
+            duration,
+            result.exit_code,
+            result.status,
+            short(detail, 500),
+        )
+        self.recent.append(run)
+        path = self.log_path
+        if path is None:
+            return
+        try:
+            self.session.ensure()
+            with path.open("a", encoding="utf-8", newline="\n") as stream:
+                stream.write(json.dumps(run.record(), ensure_ascii=False) + "\n")
+        except OSError:
+            pass  # The log is a convenience; a full disk must not break a turn.

mosscode/hooks/events.py

@@ -0,0 +1,48 @@
+"""The hook events, their condition fields, allowed actions and how they run."""
+
+from dataclasses import dataclass
+
+ACTIONS = ("command", "prompt", "http", "agent")
+EXTERNAL = ("command", "http", "agent")
+COMMON_FIELDS = ("event", "agent", "agent_type")
+TOOL_FIELDS = ("tool", "path", "command", "worktree")  # Worktree is "" outside one.
+
+
+@dataclass(frozen=True)
+class EventSpec:
+    fields: tuple[str, ...]
+    actions: tuple[str, ...]
+    background: bool = False  # Command, http and agent actions always run in the background.
+    sync_only: bool = False  # pre_tool_use: async is not allowed.
+    feedback: bool = False  # Command output may be injected.
+    tool: bool = False  # args.<name> fields; MOSSCODE_TOOL_NAME and MOSSCODE_FILE_PATH.
+
+
+EVENTS: dict[str, EventSpec] = {
+    "session_start": EventSpec(("source",), ACTIONS, feedback=True),
+    "session_end": EventSpec(("reason",), EXTERNAL),
+    "turn_start": EventSpec(("prompt",), ACTIONS, feedback=True),
+    "turn_end": EventSpec(("reason",), EXTERNAL),
+    "pre_send": EventSpec(("iteration",), ACTIONS, background=True),
+    "post_receive": EventSpec(("iteration", "tool_calls"), EXTERNAL, background=True),
+    "pre_tool_use": EventSpec(TOOL_FIELDS, ACTIONS, sync_only=True, feedback=True, tool=True),
+    "post_tool_use": EventSpec((*TOOL_FIELDS, "error", "code"), ACTIONS, feedback=True, tool=True),
+    "permission_request": EventSpec((*TOOL_FIELDS, "risk"), EXTERNAL, background=True, tool=True),
+    "compact": EventSpec(("trigger",), EXTERNAL),
+    "error": EventSpec(("error",), EXTERNAL),
+    # Fired on the side that started the sub-agent; agent_type here is the sub-agent's.
+    "subagent_start": EventSpec(
+        ("task_id", "description", "background", "worktree"), ("command", "http", "prompt"), feedback=True
+    ),
+    "subagent_stop": EventSpec(
+        ("task_id", "status", "background", "worktree", "worktree_kept"), EXTERNAL, background=True
+    ),
+}
+
+# The only events a fork sub-agent fires.
+TOOL_EVENTS = frozenset(name for name, spec in EVENTS.items() if spec.tool)
+ALL_FIELDS = frozenset((*COMMON_FIELDS, *(field for spec in EVENTS.values() for field in spec.fields)))
+
+
+def fields_of(event: str) -> tuple[str, ...]:
+    return (*COMMON_FIELDS, *EVENTS[event].fields)

mosscode/launcher.py

@@ -0,0 +1,177 @@
+"""The `moss` / `mosscode` command.
+
+Arguments, --help, --version and the subcommands are handled with nothing heavy imported; a session
+imports the rest through cli.run.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+OUTPUT_FORMATS = ("text", "json", "stream-json")
+SUBCOMMANDS = ("setup", "doctor")
+NAMES = ("moss", "mosscode")
+USAGE = "%(prog)s [选项] [PROMPT]\n       %(prog)s setup | doctor"
+DESCRIPTION = "MossCode：终端中的 coding agent。在项目目录中运行即可开始。"
+EXAMPLES = """\
+子命令：
+  setup                 创建用户级配置 ~/.mosscode/config.yaml
+  doctor                检查安装、配置和依赖工具，不发送请求
+
+例子：
+  moss                                   在当前目录启动交互界面
+  moss "解释这个项目的入口"               启动后立即发送这条消息
+  moss -p "列出 src 下的模块"             无界面执行一次任务后退出
+  Get-Content error.log | moss -p "解释这个错误"
+  moss -c                                恢复本项目最近的会话
+
+moss 与 mosscode 是同一个命令。要把 setup 或 doctor 当作消息发送，写成 moss -- doctor。
+"""
+
+
+def version() -> str:
+    from importlib.metadata import PackageNotFoundError
+    from importlib.metadata import version as installed
+
+    try:
+        return installed("mosscode")
+    except PackageNotFoundError:  # Run from a source tree that was never installed.
+        return "0+unknown"
+
+
+def program() -> str:
+    name = Path(sys.argv[0]).stem if sys.argv and sys.argv[0] else ""
+    return name if name in NAMES else "moss"
+
+
+def _permission_mode(value: str) -> str:
+    from .permissions import PermissionConfigError, normalize_mode
+
+    try:
+        return normalize_mode(value)
+    except PermissionConfigError as exc:
+        raise argparse.ArgumentTypeError(str(exc)) from None
+
+
+def parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog=program(),
+        usage=USAGE,
+        description=DESCRIPTION,
+        epilog=EXAMPLES,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "initial", nargs="?", metavar="PROMPT", help="启动后立即发送的第一条消息；与 -p 一起用时是无界面执行的任务"
+    )
+    parser.add_argument("-v", "--version", action="version", version=f"mosscode {version()}", help="显示版本后退出")
+    parser.add_argument(
+        "-p", "--prompt", nargs="?", const="", help="无界面执行一次任务并输出结果；管道输入附在任务之后"
+    )
+    parser.add_argument(
+        "-c", "--continue", dest="continue_session", action="store_true", help="恢复本项目最近活动的会话"
+    )
+    parser.add_argument(
+        "--resume", nargs="?", const="", metavar="ID", help="恢复指定会话；不带 ID 时在交互界面中打开会话列表"
+    )
+    parser.add_argument("--config", help="YAML 配置路径；默认依次查找 .mosscode/config.yaml、~/.mosscode/config.yaml")
+    parser.add_argument("--provider", help="指定命名 Provider，跳过启动选择；无界面模式默认使用 default_provider")
+    parser.add_argument(
+        "--permission-mode",
+        type=_permission_mode,
+        metavar="MODE",
+        help="权限档位：default/acceptEdits/plan/bypassPermissions；仍遵守硬限制和显式拒绝",
+    )
+    parser.add_argument(
+        "--output-format",
+        choices=OUTPUT_FORMATS,
+        default="text",
+        help="无界面输出格式：text（默认，流式正文）、json（结束时输出一个结果对象）、stream-json（每行一个 JSON 事件）",
+    )
+    parser.add_argument("--show-usage", action="store_true", help="text 格式在 stderr 显示逐次请求的 Token 与缓存用量")
+    parser.add_argument("--list-providers", action="store_true", help="列出配置，不发请求")
+    parser.add_argument("--no-hooks", action="store_true", help="本次运行不加载任何 Hook")
+    parser.add_argument(
+        "--trust-project-hooks",
+        action="store_true",
+        help="本次运行信任项目级 Hook 文件（不写入确认记录），用于无界面模式",
+    )
+    # A team member in a pane of its own; started by the lead, not by hand.
+    parser.add_argument("--team-dir", help=argparse.SUPPRESS)
+    parser.add_argument("--team-member", help=argparse.SUPPRESS)
+    return parser
+
+
+def parse_arguments(argv: list[str] | None = None) -> argparse.Namespace:
+    """Parse and check the combinations; exits with 2 on a mistake, as argparse does."""
+    command = parser()
+    args = command.parse_args(argv)
+    if (args.team_dir is None) != (args.team_member is None):
+        command.error("--team-dir 和 --team-member 需要一起使用。")
+    if args.prompt is not None:  # The task is the value of -p or the positional prompt, not both.
+        if args.prompt and args.initial is not None:
+            command.error("无界面任务只能给一个：-p 的值或位置参数 PROMPT。")
+        if not args.prompt and args.initial is not None:
+            args.prompt = args.initial
+        args.initial = None
+    if args.output_format != "text" and args.prompt is None:
+        command.error("--output-format 只用于 -p/--prompt 无界面模式。")
+    if args.continue_session and args.resume is not None:
+        command.error("--continue 和 --resume 只能选择一个。")
+    if args.resume == "" and args.prompt is not None:
+        command.error("无界面模式中 --resume 需要会话 ID；恢复最近的会话请用 --continue。")
+    if args.resume == "" and args.initial is not None:
+        command.error("打开会话列表时不能同时给出第一条消息；请用 --resume ID 或 -c。")
+    return args
+
+
+def is_terminal(stream) -> bool:
+    try:
+        return stream is not None and stream.isatty()
+    except (AttributeError, ValueError, OSError):
+        return False
+
+
+def with_stdin(prompt: str, stdin=None) -> str:
+    """Piped input follows the task after a blank line; alone, it is the task."""
+    stdin = sys.stdin if stdin is None else stdin
+    if is_terminal(stdin) or stdin is None:
+        return prompt
+    try:
+        piped = stdin.read()
+    except (OSError, ValueError, UnicodeError):
+        return prompt
+    piped = piped.strip("\n")
+    if not piped.strip():
+        return prompt
+    return f"{prompt}\n\n{piped}" if prompt.strip() else piped
+
+
+def _subcommand(name: str, argv: list[str]) -> int:
+    if name == "setup":
+        from .setup import main as setup
+
+        return setup(argv)
+    from .doctor import main as doctor
+
+    return doctor(argv)
+
+
+def main(argv: list[str] | None = None) -> None:
+    argv = sys.argv[1:] if argv is None else list(argv)
+    if argv and argv[0] in SUBCOMMANDS:
+        raise SystemExit(_subcommand(argv[0], argv[1:]))
+    args = parse_arguments(argv)
+    if args.team_dir is None and not args.list_providers:
+        if args.prompt is not None:
+            args.prompt = with_stdin(args.prompt)
+            if not args.prompt.strip():
+                parser().error("-p 需要任务：写在 -p 之后，或通过管道输入。")
+        elif not is_terminal(sys.stdin):
+            print("MossCode: 交互界面需要终端；无界面执行请用 -p。", file=sys.stderr)
+            raise SystemExit(2)
+    from .cli import run
+
+    run(args)