dsh-conductor 0.3.0__py3-none-any.whl

conductor/__init__.py

@@ -0,0 +1,24 @@
+"""由 DSH 管理运行在 tmux 中的编码 agent。"""
+
+from .dsh import DshClient, DshConfig, DshError, RunResult
+from .models import AgentKind, ExecutionPlan, Verdict
+from .progress import RunEvent
+from .sdk import Conductor, ConductorConfig, ConductorError, TaskResult
+
+__version__ = "0.3.0"
+
+__all__ = [
+    "AgentKind",
+    "Conductor",
+    "ConductorConfig",
+    "ConductorError",
+    "DshClient",
+    "DshConfig",
+    "DshError",
+    "RunResult",
+    "RunEvent",
+    "TaskResult",
+    "ExecutionPlan",
+    "Verdict",
+    "__version__",
+]

conductor/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

conductor/agents/__init__.py

@@ -0,0 +1 @@
+"""不同 agent 各自独立的 tmux 协议。"""

conductor/agents/base.py

@@ -0,0 +1,355 @@
+"""共享控制器机制；所有 TUI 差异由具体 adapter 负责。"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shlex
+import shutil
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Pattern, Sequence
+
+from ..models import RecordError, WorkerReceipt
+from ..state import atomic_write_json
+from ..tmux import TmuxError, TmuxSession
+
+
+class WorkerError(RuntimeError):
+    """worker 会话未能到达可验证的交接点。"""
+
+
+@dataclass(frozen=True, slots=True)
+class AgentAdapter:
+    kind: str
+    executable: str
+    arguments: tuple[str, ...]
+    cursor_glyphs: tuple[str, ...]
+    menu_hint: Pattern[str]
+    affirmative: Pattern[str]
+    ready: Pattern[str]
+    pending_submission: Pattern[str] | None = None
+
+    def resolve_command(self, explicit_binary: str | None = None) -> list[str]:
+        raw = explicit_binary or shutil.which(self.executable)
+        if not raw:
+            raise WorkerError(f"cannot find {self.executable} on PATH; pass --binary")
+        binary = Path(raw).expanduser().resolve()
+        if not binary.is_file():
+            raise WorkerError(f"agent executable does not exist: {binary}")
+        return [str(binary), *self.arguments]
+
+    def cursor_label(self, screen: str) -> str | None:
+        for line in screen.splitlines():
+            for glyph in self.cursor_glyphs:
+                if glyph in line:
+                    label = line.split(glyph, 1)[1].strip()
+                    return re.sub(r"^\d+[.)]\s*", "", label)
+        return None
+
+    def is_menu(self, screen: str) -> bool:
+        return bool(self.menu_hint.search(screen))
+
+    def is_ready(self, screen: str) -> bool:
+        return not self.is_menu(screen) and bool(self.ready.search(screen))
+
+    def has_pending_submission(self, screen: str) -> bool:
+        return self.pending_submission is not None and bool(self.pending_submission.search(screen))
+
+
+def _emit(value: object) -> None:
+    json.dump(value, sys.stdout, ensure_ascii=False)
+    sys.stdout.write("\n")
+    sys.stdout.flush()
+
+
+def _submission_prompt(*, task_file: Path, script: Path, receipt: Path, token: str) -> str:
+    # TUI 只接收短指令；任务正文留在文件中，避免长粘贴在交互式编辑器中被截断。
+    command = (
+        f"python3.13 {shlex.quote(str(script))} complete "
+        f"--receipt {shlex.quote(str(receipt))} --token {shlex.quote(token)} "
+        "--status ready_for_verification --summary '简短事实总结'"
+    )
+    blocked = command.replace("ready_for_verification", "blocked")
+    return f"""
+<dsh_conductor_handoff>
+请完整读取任务文件 `{task_file}`，自主完成其中的任务和自检。该文件不是验收结论。
+全部编辑与检查结束后，最后一个工具操作必须运行下列命令，并把 summary 占位文字改为简短事实总结：
+
+{command}
+
+如果外部阻塞导致无法完成，改用下列命令，并在 summary 中说明阻塞原因：
+
+{blocked}
+
+写入回执后不要继续工作。回执只表示可以交给 DSH 独立验收，不表示任务已经通过验收。
+</dsh_conductor_handoff>
+""".strip()
+
+
+def wait_until_ready(
+    session: TmuxSession,
+    adapter: AgentAdapter,
+    *,
+    timeout_seconds: float,
+    ready_settle_seconds: float = 2.0,
+) -> None:
+    deadline = time.monotonic() + timeout_seconds
+    menu_steps = 0
+    ready_since: float | None = None
+    while time.monotonic() < deadline:
+        screen = session.capture()
+        status = session.status()
+        if status.pane_dead:
+            raise WorkerError(f"{adapter.kind} exited during startup\n{screen[-2000:]}")
+        if adapter.is_menu(screen):
+            ready_since = None
+            label = adapter.cursor_label(screen)
+            if label and adapter.affirmative.search(label):
+                session.send_keys("Enter")
+                time.sleep(1.0)
+                menu_steps = 0
+                continue
+            if menu_steps >= 8:
+                raise WorkerError(f"cannot find an affirmative startup option\n{screen[-2000:]}")
+            menu_steps += 1
+            session.send_keys("Down")
+            # Claude Code 异步重绘菜单；过早读屏会看到旧光标并误判为没有移动。
+            time.sleep(0.75)
+            continue
+        if adapter.is_ready(screen):
+            # 启动界面可能先显示输入框，随后才弹出目录信任菜单；稳定后再粘贴任务。
+            if ready_since is None:
+                ready_since = time.monotonic()
+            elif time.monotonic() - ready_since >= ready_settle_seconds:
+                return
+        else:
+            ready_since = None
+        time.sleep(0.5)
+    raise WorkerError(f"{adapter.kind} did not become ready\n{session.capture()[-2000:]}")
+
+
+def wait_for_receipt(
+    session: TmuxSession,
+    *,
+    adapter: AgentAdapter,
+    receipt_file: Path,
+    token: str,
+    timeout_seconds: float,
+    submission: str,
+) -> tuple[WorkerReceipt, float]:
+    started = time.monotonic()
+    deadline = started + timeout_seconds
+    last_error: str | None = None
+    menu_steps = 0
+    resubmit_after_menu = False
+    last_submit = time.monotonic()
+    while time.monotonic() < deadline:
+        if receipt_file.exists():
+            try:
+                receipt = WorkerReceipt.load(receipt_file, expected_token=token)
+                return receipt, time.monotonic() - started
+            except RecordError as exc:
+                last_error = str(exc)
+        screen = session.capture()
+        if adapter.is_menu(screen):
+            label = adapter.cursor_label(screen)
+            if label and adapter.affirmative.search(label):
+                session.send_keys("Enter")
+                menu_steps = 0
+                resubmit_after_menu = True
+                time.sleep(1.0)
+                continue
+            if menu_steps >= 8:
+                raise WorkerError(f"cannot handle worker menu while waiting for receipt\n{screen[-2000:]}")
+            session.send_keys("Down")
+            menu_steps += 1
+            time.sleep(0.75)
+            continue
+        if resubmit_after_menu and adapter.is_ready(screen):
+            # 菜单可能截断首次粘贴；清空残留输入后完整重投，不能只补发 Enter。
+            session.send_keys("C-c")
+            time.sleep(0.25)
+            session.send_text(submission)
+            resubmit_after_menu = False
+            last_submit = time.monotonic()
+            time.sleep(0.5)
+            continue
+        if adapter.has_pending_submission(screen) and time.monotonic() - last_submit >= 2.0:
+            # Codex 可能在 Enter 到达后才完成 bracketed paste。仅当编辑器仍显示
+            # pending-paste 标记时节流重发，避免无依据地重复提交任务。
+            session.send_keys("Enter")
+            last_submit = time.monotonic()
+            time.sleep(0.5)
+            continue
+        if session.status().pane_dead:
+            raise WorkerError(f"worker process exited before writing its receipt\n{screen[-2000:]}")
+        time.sleep(0.5)
+    detail = f"; last receipt error: {last_error}" if last_error else ""
+    raise WorkerError(f"timed out waiting for worker receipt {receipt_file}{detail}")
+
+
+def submit(
+    *,
+    session: TmuxSession,
+    adapter: AgentAdapter,
+    task_file: Path,
+    receipt_file: Path,
+    token: str,
+    script: Path,
+    timeout_seconds: float,
+) -> dict[str, object]:
+    if receipt_file.exists():
+        raise WorkerError(f"refusing stale receipt path: {receipt_file}")
+    try:
+        task = task_file.read_text(encoding="utf-8")
+    except OSError as exc:
+        raise WorkerError(f"cannot read task file {task_file}: {exc}") from exc
+    if not task.strip():
+        raise WorkerError(f"task file is empty: {task_file}")
+    receipt_file.parent.mkdir(parents=True, exist_ok=True)
+    prompt = _submission_prompt(
+        task_file=task_file.resolve(),
+        script=script,
+        receipt=receipt_file.resolve(),
+        token=token,
+    )
+    session.send_text(prompt)
+    # 长文本粘贴可能在首个 Enter 后才完成展开；菜单由后续分支处理，其余状态只补交一次。
+    time.sleep(2.0)
+    if not receipt_file.exists() and not adapter.is_menu(session.capture()):
+        session.send_keys("Enter")
+    receipt, elapsed = wait_for_receipt(
+        session,
+        adapter=adapter,
+        receipt_file=receipt_file,
+        token=token,
+        timeout_seconds=timeout_seconds,
+        submission=prompt,
+    )
+    return {
+        "schema_version": 1,
+        "session": session.name,
+        "agent": adapter.kind,
+        "status": receipt.status,
+        "summary": receipt.summary,
+        "receipt_file": str(receipt_file.resolve()),
+        "elapsed_seconds": round(elapsed, 3),
+        "attach_command": f"tmux attach -t {session.name}",
+    }
+
+
+def build_parser(adapter: AgentAdapter) -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog=f"{adapter.kind}_session.py",
+        description=f"Control one {adapter.kind} interactive session through tmux.",
+    )
+    commands = parser.add_subparsers(dest="command", required=True)
+
+    run = commands.add_parser("run", help="start a session, submit a task, and wait for its receipt")
+    run.add_argument("--workspace", type=Path, required=True)
+    run.add_argument("--session", required=True)
+    run.add_argument("--task-file", type=Path, required=True)
+    run.add_argument("--receipt", type=Path, required=True)
+    run.add_argument("--token", required=True)
+    run.add_argument("--binary")
+    run.add_argument("--startup-timeout-seconds", type=float, default=120.0)
+    run.add_argument("--timeout-seconds", type=float, default=1200.0)
+
+    send = commands.add_parser("send", help="submit a follow-up to the same session")
+    send.add_argument("--session", required=True)
+    send.add_argument("--task-file", type=Path, required=True)
+    send.add_argument("--receipt", type=Path, required=True)
+    send.add_argument("--token", required=True)
+    send.add_argument("--timeout-seconds", type=float, default=1200.0)
+
+    for name in ("status", "capture", "close"):
+        command = commands.add_parser(name)
+        command.add_argument("--session", required=True)
+    capture = commands.choices["capture"]
+    capture.add_argument("--history-lines", type=int, default=0)
+
+    complete = commands.add_parser("complete", help="atomically write a worker receipt")
+    complete.add_argument("--receipt", type=Path, required=True)
+    complete.add_argument("--token", required=True)
+    complete.add_argument(
+        "--status",
+        choices=("ready_for_verification", "blocked"),
+        required=True,
+    )
+    complete.add_argument("--summary", required=True)
+    return parser
+
+
+def main(adapter: AgentAdapter, argv: Sequence[str] | None = None) -> int:
+    parser = build_parser(adapter)
+    args = parser.parse_args(argv)
+    script = Path(sys.argv[0]).resolve()
+    try:
+        if args.command == "complete":
+            if args.receipt.exists():
+                raise WorkerError(f"receipt already exists: {args.receipt}")
+            atomic_write_json(
+                args.receipt.resolve(),
+                WorkerReceipt(args.token, args.status, args.summary).to_json(),
+            )
+            _emit({"schema_version": 1, "status": "receipt_written", "receipt": str(args.receipt)})
+            return 0
+        if args.command == "run":
+            session = TmuxSession.create(
+                name=args.session,
+                workspace=args.workspace,
+                agent=adapter.kind,
+                command=adapter.resolve_command(args.binary),
+            )
+            try:
+                wait_until_ready(session, adapter, timeout_seconds=args.startup_timeout_seconds)
+                _emit(
+                    submit(
+                        session=session,
+                        adapter=adapter,
+                        task_file=args.task_file,
+                        receipt_file=args.receipt,
+                        token=args.token,
+                        script=script,
+                        timeout_seconds=args.timeout_seconds,
+                    )
+                )
+                return 0
+            except Exception:
+                # 失败会话保留给 DSH 或调用方排查，不能在异常路径中销毁现场。
+                raise
+        session = TmuxSession.attach(name=args.session, expected_agent=adapter.kind)
+        if args.command == "send":
+            _emit(
+                submit(
+                    session=session,
+                    adapter=adapter,
+                    task_file=args.task_file,
+                    receipt_file=args.receipt,
+                    token=args.token,
+                    script=script,
+                    timeout_seconds=args.timeout_seconds,
+                )
+            )
+        elif args.command == "status":
+            _emit({"schema_version": 1, **session.status().to_json()})
+        elif args.command == "capture":
+            _emit(
+                {
+                    "schema_version": 1,
+                    **session.status().to_json(),
+                    "screen": session.capture(history_lines=args.history_lines),
+                }
+            )
+        elif args.command == "close":
+            session.close()
+            _emit({"schema_version": 1, "status": "closed", "session": args.session})
+        return 0
+    except (WorkerError, TmuxError, RecordError, OSError) as exc:
+        print(f"{adapter.kind}_session: {exc}", file=sys.stderr)
+        return 1

conductor/agents/claude.py

@@ -0,0 +1,23 @@
+"""Claude Code 的 tmux 启动与就绪协议。"""
+
+from __future__ import annotations
+
+import re
+
+from .base import AgentAdapter, main as adapter_main
+
+
+# 菜单与就绪表达式只描述 Claude Code，不能与 Codex 的界面规则混用。
+CLAUDE = AgentAdapter(
+    kind="claude",
+    executable="claude",
+    arguments=("--dangerously-skip-permissions",),
+    cursor_glyphs=("❯",),
+    menu_hint=re.compile(r"Enter to confirm|Esc to cancel|to navigate|to select", re.IGNORECASE),
+    affirmative=re.compile(r"^(yes|trust|accept|continue|allow|approve)\b", re.IGNORECASE),
+    ready=re.compile(r"❯|bypass permissions on", re.IGNORECASE),
+)
+
+
+def main(argv: list[str] | None = None) -> int:
+    return adapter_main(CLAUDE, argv)

conductor/agents/codex.py

@@ -0,0 +1,24 @@
+"""Codex 的 tmux 启动与就绪协议。"""
+
+from __future__ import annotations
+
+import re
+
+from .base import AgentAdapter, main as adapter_main
+
+
+# pending_submission 是 Codex 长文本粘贴尚未提交的明确界面事实。
+CODEX = AgentAdapter(
+    kind="codex",
+    executable="codex",
+    arguments=("--dangerously-bypass-approvals-and-sandbox", "--no-alt-screen"),
+    cursor_glyphs=("›",),
+    menu_hint=re.compile(r"Press enter to continue|to navigate|to select", re.IGNORECASE),
+    affirmative=re.compile(r"^(yes|continue|allow|approve)\b", re.IGNORECASE),
+    ready=re.compile(r"›|permissions:\s*YOLO", re.IGNORECASE),
+    pending_submission=re.compile(r"^› \[Pasted Content \d+ chars\]", re.MULTILINE),
+)
+
+
+def main(argv: list[str] | None = None) -> int:
+    return adapter_main(CODEX, argv)

conductor/cli.py

@@ -0,0 +1,234 @@
+"""conductor 命令行入口；任务执行统一委托给 Python SDK。"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import os
+import shutil
+import sys
+from pathlib import Path
+from typing import Any, Sequence
+
+from . import __version__
+from .dsh import DshError, probe_dsh
+from .models import AgentKind, RecordError, read_json_object
+from .progress import RunEvent
+from .sdk import Conductor, ConductorConfig, ConductorError
+from .skills import (
+    dsh_home,
+    prepare_workspace_skills,
+    source_skill,
+)
+from .state import default_state_root
+
+type JsonObject = dict[str, Any]
+
+
+def _json(value: object) -> None:
+    # stdout 是机器协议通道，进度和诊断统一由 SDK 事件回调写 stderr。
+    json.dump(value, sys.stdout, ensure_ascii=False, indent=2)
+    sys.stdout.write("\n")
+
+
+def _event_to_stderr(event: RunEvent) -> None:
+    print(event.format(), file=sys.stderr)
+
+
+def cmd_install_skills(args: argparse.Namespace) -> int:
+    workspace = args.workspace.expanduser().resolve()
+    if not workspace.is_dir():
+        raise DshError(f"workspace is not a directory: {workspace}")
+    skill_root = prepare_workspace_skills(workspace)
+    records: list[JsonObject] = []
+    for kind in AgentKind:
+        source = source_skill(kind)
+        target = skill_root / kind.skill_name
+        record: JsonObject = {
+            "name": kind.skill_name,
+            "status": "overwritten",
+            "source": str(source),
+            "target": str(target),
+        }
+        records.append(record)
+    _json(
+        {
+            "schema_version": 1,
+            "status": "ok",
+            "workspace": str(workspace),
+            "skill_dir": str(skill_root),
+            "skills": records,
+        }
+    )
+    return 0
+
+
+def cmd_doctor(args: argparse.Namespace) -> int:
+    home = dsh_home(args.dsh_home)
+    checks: list[JsonObject] = []
+
+    def add(name: str, ok: bool, detail: object, *, required: bool = True) -> None:
+        checks.append({"name": name, "ok": ok, "required": required, "detail": str(detail)})
+
+    add("python", sys.version_info >= (3, 13), sys.version.split()[0])
+    tmux = shutil.which("tmux")
+    add("tmux", tmux is not None, tmux or "not found")
+    try:
+        add("dsh", True, probe_dsh(args.dsh_bin))
+    except DshError as exc:
+        add("dsh", False, exc)
+    available_workers: list[str] = []
+    for kind in AgentKind:
+        try:
+            add(kind.skill_name, True, source_skill(kind))
+        except DshError as exc:
+            add(kind.skill_name, False, exc)
+        binary = shutil.which(kind.value)
+        add(f"worker:{kind.value}", binary is not None, binary or "not found", required=False)
+        if binary:
+            available_workers.append(kind.value)
+    add("worker:any", bool(available_workers), ", ".join(available_workers) or "neither claude nor codex found")
+    credentials = home / ".credentials.yaml"
+    authenticated = credentials.is_file() or bool(os.environ.get("DEEPSEEK_API_KEY"))
+    add("dsh-credentials", authenticated, credentials if credentials.is_file() else "not found")
+    ok = all(check["ok"] for check in checks if check["required"])
+    _json({"schema_version": 1, "status": "ok" if ok else "error", "checks": checks})
+    return 0 if ok else 1
+
+
+def cmd_run(args: argparse.Namespace) -> int:
+    workspace = args.workspace.expanduser().resolve()
+    try:
+        config = ConductorConfig(
+            dsh_bin=args.dsh_bin,
+            dsh_home=args.dsh_home,
+            state_dir=args.state_dir,
+            provider=args.provider,
+            model=args.model,
+            max_attempts=args.max_attempts,
+            attempt_timeout_seconds=args.attempt_timeout_seconds,
+            timeout_seconds=args.timeout_seconds,
+            keep_session=args.keep_session,
+            heartbeat_seconds=args.heartbeat_seconds,
+            worker_log=args.worker_log,
+            worker_log_interval_seconds=args.worker_log_interval_seconds,
+        )
+        result = Conductor(workspace, config).run(
+            args.prompt,
+            on_event=None if args.quiet else _event_to_stderr,
+        )
+    except (ConductorError, ValueError, OSError) as exc:
+        if isinstance(exc, ConductorError):
+            _json(exc.to_json())
+        else:
+            _json({"schema_version": 1, "status": "error", "error": str(exc)})
+        return 1
+    _json(result.to_json())
+    return 0 if result.accepted else 1
+
+
+def cmd_show(args: argparse.Namespace) -> int:
+    state_root = args.state_dir.expanduser().resolve()
+    if args.run_id:
+        run_root = state_root / "runs" / args.run_id
+    else:
+        try:
+            latest = read_json_object(state_root / "latest.json")
+            run_root = Path(str(latest["run_directory"]))
+        except (RecordError, KeyError) as exc:
+            _json({"schema_version": 1, "status": "error", "error": f"cannot resolve latest run: {exc}"})
+            return 1
+    try:
+        request = read_json_object(run_root / "request.json")
+    except RecordError as exc:
+        _json({"schema_version": 1, "status": "error", "error": str(exc)})
+        return 1
+    output: JsonObject = {"schema_version": 1, "run_directory": str(run_root), "request": request}
+    for name in ("user-prompt.md", "manager-prompt.md", "plan.json", "verdict.json", "worker-screen.log"):
+        path = run_root / name
+        if not path.exists():
+            continue
+        if path.suffix == ".json":
+            try:
+                output[path.stem] = read_json_object(path)
+            except RecordError as exc:
+                output[f"{path.stem}_error"] = str(exc)
+        elif path.suffix == ".log":
+            output["worker_log"] = str(path)
+        else:
+            output[path.stem.replace("-", "_")] = path.read_text(encoding="utf-8")
+    _json(output)
+    return 0
+
+
+def _positive(value: str) -> int:
+    parsed = int(value)
+    if parsed <= 0:
+        raise argparse.ArgumentTypeError("must be greater than zero")
+    return parsed
+
+
+def _positive_float(value: str) -> float:
+    parsed = float(value)
+    if not math.isfinite(parsed) or parsed <= 0:
+        raise argparse.ArgumentTypeError("must be greater than zero")
+    return parsed
+
+
+def _non_empty(value: str) -> str:
+    if not value.strip():
+        raise argparse.ArgumentTypeError("must not be empty")
+    return value
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="conductor", description="通过 DSH 管理并验收编码任务。")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    commands = parser.add_subparsers(dest="command", required=True)
+    run = commands.add_parser("run", help="运行一个包含任务与验收标准的 prompt")
+    run.add_argument("--workspace", type=Path, required=True)
+    run.add_argument("--prompt", type=_non_empty, required=True)
+    run.add_argument("--max-attempts", type=_positive, default=2)
+    run.add_argument("--attempt-timeout-seconds", type=_positive, default=1200)
+    run.add_argument("--timeout-seconds", type=_positive_float, default=3600.0)
+    run.add_argument("--provider", default="deepseek-official")
+    run.add_argument("--model", default="deepseek-flash")
+    run.add_argument("--dsh-bin")
+    run.add_argument("--dsh-home", type=Path)
+    run.add_argument("--state-dir", type=Path, default=default_state_root())
+    run.add_argument("--keep-session", action="store_true")
+    run.add_argument("--quiet", action="store_true")
+    run.add_argument("--heartbeat-seconds", type=_positive_float, default=10.0)
+    run.add_argument("--worker-log", action=argparse.BooleanOptionalAction, default=True)
+    run.add_argument(
+        "--worker-log-interval-seconds",
+        type=_positive_float,
+        default=5.0,
+        help="tmux worker 屏幕采样间隔，默认 5 秒",
+    )
+    run.set_defaults(func=cmd_run)
+    install = commands.add_parser("install-skills", help="将两个 skill 复制到指定 workspace")
+    install.add_argument("--workspace", type=Path, required=True)
+    install.set_defaults(func=cmd_install_skills)
+    doctor = commands.add_parser("doctor")
+    doctor.add_argument("--dsh-bin")
+    doctor.add_argument("--dsh-home", type=Path)
+    doctor.set_defaults(func=cmd_doctor)
+    show = commands.add_parser("show")
+    show.add_argument("--run-id")
+    show.add_argument("--state-dir", type=Path, default=default_state_root())
+    show.set_defaults(func=cmd_show)
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        return args.func(args)
+    except KeyboardInterrupt:
+        _json({"schema_version": 1, "status": "error", "error": "interrupted"})
+        return 130
+    except (DshError, OSError) as exc:
+        _json({"schema_version": 1, "status": "error", "error": str(exc)})
+        return 1