dscli-agent 0.1.0__py3-none-any.whl

dscli/cli.py

@@ -0,0 +1,842 @@
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import sys
+import time
+from dataclasses import fields
+from pathlib import Path
+
+from playwright.sync_api import Error as PlaywrightError
+
+from . import __version__, ui
+from .agent import run_agent
+from .attachments import AttachmentError, collect_attachments
+from .browser import (
+    BrowserError,
+    ChatError,
+    ChatSession,
+    HumanCheckRequired,
+    LoginRequired,
+    UploadError,
+)
+from .config import (
+    Config,
+    config_path,
+    ensure_config_file,
+    load_config,
+    parse_scalar,
+)
+from .prompts import build_initial_prompt
+from .protocol import ProtocolError
+from .tools import ApprovalRequired, Toolbox, workspace_preview
+
+log = logging.getLogger("dscli")
+
+
+def _utf8_stdio() -> None:
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(encoding="utf-8", errors="replace")
+        except (AttributeError, OSError):
+            pass
+
+
+def _setup_logging(
+    verbose: bool,
+    quiet: bool,
+    handler: logging.Handler | None = None,
+) -> None:
+    level = logging.DEBUG if verbose else logging.WARNING if quiet else logging.INFO
+    if handler is not None:
+        handler.setLevel(level)
+        logging.basicConfig(
+            level=level,
+            handlers=[handler],
+            format="%(message)s",
+            force=True,
+        )
+    else:
+        logging.basicConfig(
+            level=level,
+            format="%(message)s",
+            stream=sys.stderr,
+            force=True,
+        )
+    logging.getLogger("asyncio").setLevel(logging.WARNING)
+
+
+def _add_headless_flags(parser: argparse.ArgumentParser) -> None:
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument("--headed", action="store_true", help="Show the browser window.")
+    group.add_argument("--headless", action="store_true", help="Run the browser headless.")
+
+
+def _add_toggle_flags(parser: argparse.ArgumentParser) -> None:
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument("--deepthink", dest="deepthink", action="store_true", default=None,
+                       help="Enable DeepSeek's DeepThink mode.")
+    group.add_argument("--no-deepthink", dest="deepthink", action="store_false",
+                       help="Disable DeepThink (default).")
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument("--search", dest="search", action="store_true", default=None,
+                       help="Enable DeepSeek web search.")
+    group.add_argument("--no-search", dest="search", action="store_false",
+                       help="Disable web search (default).")
+
+
+def _add_agent_flags(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--workspace", default=None,
+                        help="Workspace root (default: current directory).")
+    parser.add_argument("-y", "--yes", action="store_true",
+                        help="Approve file writes and commands automatically.")
+    parser.add_argument("--allow-shell", action="store_true",
+                        help="Allow run_command (still approved per command).")
+    parser.add_argument("--allow-outside", action="store_true",
+                        help="Allow tools to access paths outside the workspace.")
+    parser.add_argument("--max-steps", type=int, default=None,
+                        help="Maximum model turns per request.")
+    parser.add_argument("--timeout", type=int, default=None,
+                        help="Response timeout per turn, seconds.")
+    parser.add_argument("--no-auto-login", action="store_true",
+                        help="Do not open a visible browser when a headless login is needed.")
+    _add_headless_flags(parser)
+    _add_toggle_flags(parser)
+    parser.add_argument("-v", "--verbose", action="store_true",
+                        help="Show model thoughts and debug logs.")
+    parser.add_argument("-q", "--quiet", action="store_true", help="Hide progress messages.")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="dscli",
+        description="A local coding agent for your terminal.",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    login = sub.add_parser("login", help="Open a browser once and save a DeepSeek login.")
+    login.add_argument("--timeout", type=int, default=None, help="Seconds to wait for login.")
+
+    doctor = sub.add_parser("doctor", help="Inspect the DeepSeek page and selectors.")
+    doctor.add_argument("--send", action="store_true", help="Also send a one-word round-trip test.")
+    _add_headless_flags(doctor)
+    doctor.add_argument("--timeout", type=int, default=180, help="Timeout for the test message.")
+
+    chat = sub.add_parser("chat", help="Start an interactive conversation.")
+    _add_agent_flags(chat)
+    chat.add_argument("--plain", action="store_true",
+                      help="Use the plain line-based interface instead of the TUI.")
+
+    run = sub.add_parser("run", help="Run a task with file-editing tools.")
+    run.add_argument("task", nargs="*", help="The task/prompt. Use '-' to read it from stdin.")
+    run.add_argument("-f", "--file", action="append", default=[], metavar="PATH",
+                     help="Attach a file to the chat (repeatable; globs supported).")
+    run.add_argument("--prompt-file", help="Read the task from a UTF-8 text file.")
+    _add_agent_flags(run)
+    run.add_argument("--dry-run", action="store_true",
+                     help="Print the initial prompt and exit without launching a browser.")
+
+    cfg = sub.add_parser("config", help="Show or edit the saved configuration.")
+    cfg.add_argument("--show", action="store_true", help="Show the current configuration.")
+    cfg.add_argument("--set", action="append", default=[], metavar="KEY=VALUE",
+                     help="Set a config value (repeatable).")
+    cfg.add_argument("--path", action="store_true", help="Print the config file path.")
+    return parser
+
+
+def _apply_run_config(cfg: Config, args: argparse.Namespace) -> Config:
+    if args.headed:
+        cfg.headless = False
+    elif args.headless:
+        cfg.headless = True
+    if args.timeout is not None:
+        if args.timeout <= 0:
+            raise ValueError("--timeout must be greater than 0.")
+        cfg.response_timeout_sec = args.timeout
+        cfg.first_response_timeout_sec = min(cfg.first_response_timeout_sec, args.timeout)
+    if args.max_steps is not None:
+        if args.max_steps < 1:
+            raise ValueError("--max-steps must be at least 1.")
+        cfg.max_steps = min(args.max_steps, 50)
+    if args.deepthink is not None:
+        cfg.deepthink = args.deepthink
+    if args.search is not None:
+        cfg.search = args.search
+    if args.allow_shell:
+        cfg.allow_shell = True
+    if args.allow_outside:
+        cfg.allow_outside = True
+    return cfg
+
+
+def _read_task(args: argparse.Namespace, parser: argparse.ArgumentParser) -> str:
+    if args.prompt_file and args.task:
+        parser.error("Provide either a task or --prompt-file, not both.")
+    if args.prompt_file:
+        try:
+            task = Path(args.prompt_file).read_text(encoding="utf-8")
+        except OSError as exc:
+            parser.error(f"Could not read --prompt-file: {exc}")
+    elif args.task and args.task != ["-"]:
+        task = " ".join(args.task)
+    else:
+        if sys.stdin.isatty():
+            parser.error("Provide a task, use '-' to read stdin, or use --prompt-file.")
+        task = sys.stdin.read()
+    task = (task or "").strip()
+    if not task:
+        parser.error("The task is empty.")
+    return task
+
+
+def _confirm(args: argparse.Namespace):
+    auto = {"value": bool(args.yes)}
+
+    def confirm(title: str, detail: str | None) -> bool:
+        if auto["value"]:
+            return True
+        if not sys.stdin.isatty():
+            raise ApprovalRequired(
+                f"{title} needs confirmation, but stdin is not interactive. Rerun with --yes."
+            )
+        print("", file=sys.stderr)
+        print(ui.style(title, "bold"), file=sys.stderr)
+        if detail:
+            looks_like_diff = detail.lstrip().startswith("---") or "\n+++" in detail[:200]
+            if looks_like_diff:
+                ui.print_diff(detail)
+            else:
+                for line in detail.splitlines():
+                    print(ui.style("  " + line, "yellow"), file=sys.stderr)
+        print(
+            ui.style("Approve? [y]es / [n]o / [a]ll / [q]uit: ", "cyan"),
+            end="",
+            file=sys.stderr,
+            flush=True,
+        )
+        answer = (sys.stdin.readline() or "").strip().lower()
+        if answer in {"q", "quit"}:
+            raise KeyboardInterrupt
+        if answer in {"a", "all"}:
+            auto["value"] = True
+            return True
+        if answer in {"y", "yes"}:
+            return True
+        return False
+
+    return confirm
+
+
+class _FinalStreamRenderer:
+    def __init__(self) -> None:
+        self._rendered = ""
+        self._started = False
+        self._finished = False
+        self._diverged = False
+
+    def update(self, text: str) -> None:
+        if self._finished or self._diverged or not text:
+            return
+        if text == self._rendered or self._rendered.startswith(text):
+            return
+        if not text.startswith(self._rendered):
+            self._diverged = True
+            return
+        if not self._started:
+            sys.stdout.write("agent> ")
+            self._started = True
+        sys.stdout.write(text[len(self._rendered):])
+        sys.stdout.flush()
+        self._rendered = text
+
+    def finish(self, final: str) -> None:
+        if self._finished:
+            return
+        self._finished = True
+        if self._started and not self._diverged and final.startswith(self._rendered):
+            sys.stdout.write(final[len(self._rendered):])
+            if not final.endswith("\n"):
+                sys.stdout.write("\n")
+        else:
+            if self._started:
+                sys.stdout.write("\n")
+            sys.stdout.write(f"agent> {final}")
+            if not final.endswith("\n"):
+                sys.stdout.write("\n")
+        sys.stdout.write("\n")
+        sys.stdout.flush()
+        self._rendered = final
+
+    def close_line(self) -> None:
+        if self._finished:
+            return
+        self._finished = True
+        if self._started:
+            sys.stdout.write("\n")
+            sys.stdout.flush()
+
+
+def _new_session(cfg: Config, *, headless_override: bool | None = None) -> ChatSession:
+    return ChatSession(cfg, headless=headless_override)
+
+
+def _ensure_ready(
+    session: ChatSession,
+    cfg: Config,
+    *,
+    allow_auto_login: bool,
+) -> ChatSession:
+    try:
+        if not cfg.headless:
+            session.wait_for_composer(cfg.login_timeout_sec, interactive=True)
+        else:
+            session.wait_for_composer(8, interactive=False)
+        return session
+    except (LoginRequired, HumanCheckRequired) as exc:
+        if session.import_chrome_login(30):
+            return session
+        if not allow_auto_login or not cfg.headless:
+            raise
+        log.warning(str(exc))
+        log.warning("Opening a browser window for a one-time login / human check...")
+        session.close()
+        headed = _new_session(cfg, headless_override=False)
+        headed.start()
+        headed.wait_for_composer(cfg.login_timeout_sec, interactive=True)
+        log.info("Login saved. Continuing in the visible browser (future runs can be headless).")
+        return headed
+
+
+def cmd_login(args: argparse.Namespace) -> int:
+    ensure_config_file()
+    cfg = load_config()
+    cfg.headless = False
+    if args.timeout is not None:
+        cfg.login_timeout_sec = max(30, int(args.timeout))
+    session = _new_session(cfg, headless_override=False)
+    try:
+        session.login()
+    finally:
+        session.close()
+    print(f"Login profile: {cfg.profile_dir}")
+    return 0
+
+
+def cmd_doctor(args: argparse.Namespace) -> int:
+    ensure_config_file()
+    cfg = load_config()
+    if args.headed:
+        cfg.headless = False
+    elif args.headless:
+        cfg.headless = True
+    session = _new_session(cfg)
+    try:
+        session.start()
+        if cfg.headless:
+            session.wait_for_composer(10, interactive=False)
+        else:
+            session.wait_for_composer(cfg.login_timeout_sec, interactive=True)
+        diag = session.diagnostics()
+        print(f"config:              {config_path()}")
+        print(f"profile:             {diag.get('profile')}")
+        print(f"chrome session:      {diag.get('chrome_session') or '(not available)'}")
+        print(f"headless:            {diag.get('headless')}")
+        print(f"url:                 {diag.get('url')}")
+        print(f"title:               {diag.get('title')}")
+        print(f"composer:            {diag.get('composerCount')} node(s), "
+              f"visible={diag.get('composerVisible')}")
+        print(f"send button:         {diag.get('sendCount')} node(s), "
+              f"visible={diag.get('sendVisible')}, disabled={diag.get('sendDisabled')}")
+        print(f"assistant messages:  {diag.get('assistantCount')}")
+        print(f"file input:          {diag.get('fileInputCount')} node(s), "
+              f"{len((diag.get('accept') or '').split(','))} accepted token(s)")
+        print(f"cloudflare overlay:  {diag.get('cloudflareVisible')}")
+        toggles = diag.get("toggles") or []
+        if toggles:
+            desc = ", ".join(f"{t['text']}={'on' if t['pressed'] else 'off'}" for t in toggles)
+        else:
+            desc = "(not found)"
+        print(f"toggles:             {desc}")
+        labels = diag.get("newChatMatches") or []
+        print(f"new chat control:    {', '.join(labels) if labels else '(not found)'}")
+        notices = diag.get("notificationText") or []
+        if notices:
+            print(f"notifications:       {' | '.join(notices)}")
+        if args.send:
+            print("\nSending a connectivity test in a new chat...")
+            session.new_chat()
+            session.set_modes()
+            reply = session.send_and_wait(
+                "[CONNECTIVITY TEST] Reply with exactly one word: pong",
+                timeout_sec=max(60, int(args.timeout or 180)),
+            )
+            print(f"reply: {reply!r}")
+        return 0
+    finally:
+        session.close()
+
+
+def cmd_config(args: argparse.Namespace) -> int:
+    path = ensure_config_file()
+    if args.path:
+        print(path)
+        return 0
+    if args.set:
+        cfg = load_config()
+        known = {f.name for f in fields(Config)}
+        for item in args.set:
+            if "=" not in item:
+                raise SystemExit(f"Expected KEY=VALUE, got: {item}")
+            key, raw = item.split("=", 1)
+            key = key.strip()
+            if key not in known:
+                raise SystemExit(f"Unknown config key: {key}")
+            if key == "selectors":
+                raise SystemExit("Edit the selectors object directly in the config JSON file.")
+            setattr(cfg, key, parse_scalar(raw))
+        cfg.save()
+        print(f"Saved {path}")
+        args.show = True
+    if args.show or not args.set:
+        cfg = load_config()
+        print(json.dumps(cfg.to_dict(), indent=2, ensure_ascii=False))
+    return 0
+
+
+def _should_use_tui(args: argparse.Namespace) -> bool:
+    if getattr(args, "plain", False):
+        return False
+    if os.environ.get("DSCLI_PLAIN"):
+        return False
+    if os.environ.get("TERM", "").lower() == "dumb":
+        return False
+    try:
+        return sys.stdin.isatty() and sys.stdout.isatty()
+    except (AttributeError, ValueError):
+        return False
+
+
+def _try_create_tui(args: argparse.Namespace, workspace: Path):
+    try:
+        from rich.logging import RichHandler
+
+        from .tui import Tui
+    except ImportError as exc:
+        log.warning(
+            "Interactive UI unavailable (%s); using plain mode. "
+            "Install the project dependencies to enable it.",
+            exc,
+        )
+        return None
+    try:
+        tui = Tui(
+            workspace=workspace,
+            auto_approve=bool(args.yes),
+            quiet=bool(args.quiet),
+        )
+        _setup_logging(
+            bool(args.verbose),
+            bool(args.quiet),
+            handler=RichHandler(
+                console=tui.console,
+                show_time=False,
+                show_path=False,
+                markup=False,
+            ),
+        )
+        return tui
+    except Exception as exc:
+        log.warning(
+            "Could not start the interactive UI (%s); using plain mode.",
+            exc,
+        )
+        return None
+
+
+def _chat_loop_plain(
+    session: ChatSession,
+    toolbox: Toolbox,
+    cfg: Config,
+    args: argparse.Namespace,
+    workspace: Path,
+) -> int:
+    first_message = True
+    print("Interactive dscli. Type /help for commands, /exit to quit.")
+    while True:
+        try:
+            task = input("you> ").strip()
+        except EOFError:
+            print()
+            return 0
+        if not task:
+            continue
+        if task in {"/exit", "/quit"}:
+            return 0
+        if task == "/help":
+            print("/new   Start a new conversation\n/exit  Exit dscli (also /quit)")
+            continue
+        if task == "/new":
+            session.new_chat()
+            session.set_modes()
+            first_message = True
+            print("Started a new conversation.")
+            continue
+        if task.startswith("/"):
+            log.warning("Unknown command: %s. Type /help for available commands.", task)
+            continue
+
+        renderer = _FinalStreamRenderer()
+        try:
+            outcome = run_agent(
+                session=session,
+                config=cfg,
+                toolbox=toolbox,
+                task=task,
+                workspace=workspace,
+                attachments=[],
+                verbose=args.verbose,
+                quiet=args.quiet,
+                followup=not first_message,
+                on_final_snapshot=renderer.update,
+            )
+        except (ApprovalRequired, ProtocolError) as exc:
+            renderer.close_line()
+            first_message = False
+            log.error("Request error: %s", exc)
+            if toolbox.changed_files:
+                log.error("Files already changed: %s", ", ".join(toolbox.changed_files))
+            continue
+        except BaseException:
+            renderer.close_line()
+            raise
+        first_message = False
+        renderer.finish(outcome.final)
+        if outcome.limit_reached:
+            log.warning(
+                "Model-turn budget exhausted. Raise --max-steps or ask the agent to continue."
+            )
+
+
+def _chat_loop_tui(
+    session: ChatSession,
+    toolbox: Toolbox,
+    cfg: Config,
+    args: argparse.Namespace,
+    workspace: Path,
+    tui,
+) -> int:
+    from .tui import TuiQuit
+
+    first_message = True
+    while True:
+        try:
+            task = tui.prompt().strip()
+        except EOFError:
+            return 0
+        except KeyboardInterrupt:
+            tui.system("Input cleared. Ctrl+D or /exit to quit.")
+            continue
+        if not task:
+            continue
+        if task in {"/exit", "/quit"}:
+            return 0
+        if task == "/help":
+            tui.print_help()
+            continue
+        if task == "/new":
+            session.new_chat()
+            session.set_modes()
+            first_message = True
+            tui.system("Started a new conversation.")
+            continue
+        if task.startswith("/"):
+            log.warning("Unknown command: %s. Type /help for available commands.", task)
+            continue
+
+        started = time.monotonic()
+        try:
+            outcome = run_agent(
+                session=session,
+                config=cfg,
+                toolbox=toolbox,
+                task=task,
+                workspace=workspace,
+                attachments=[],
+                verbose=args.verbose,
+                quiet=args.quiet,
+                followup=not first_message,
+                on_final_snapshot=tui.answer_snapshot,
+                display=tui,
+            )
+        except (ApprovalRequired, ProtocolError) as exc:
+            first_message = False
+            tui.turn_failed(str(exc), toolbox.changed_files)
+            continue
+        except KeyboardInterrupt as exc:
+            if isinstance(exc, TuiQuit):
+                tui.close()
+                raise
+            tui.interrupted()
+            stop = getattr(session, "stop_generation", None)
+            if callable(stop):
+                try:
+                    stop()
+                except Exception:
+                    pass
+            first_message = False
+            continue
+        except BaseException:
+            tui.close()
+            raise
+        first_message = False
+        tui.complete(outcome, time.monotonic() - started)
+        if outcome.limit_reached:
+            log.warning(
+                "Model-turn budget exhausted. Raise --max-steps or ask the agent to continue."
+            )
+
+
+def cmd_chat(args: argparse.Namespace) -> int:
+    ensure_config_file()
+    cfg = _apply_run_config(load_config(), args)
+    workspace = Path(args.workspace).expanduser() if args.workspace else Path.cwd()
+    try:
+        workspace = workspace.resolve(strict=True)
+    except FileNotFoundError:
+        log.error("Workspace does not exist: %s", workspace)
+        return 1
+    if not workspace.is_dir():
+        log.error("Workspace is not a directory: %s", workspace)
+        return 1
+
+    tui = _try_create_tui(args, workspace) if _should_use_tui(args) else None
+    toolbox = Toolbox(
+        workspace,
+        allow_outside=cfg.allow_outside,
+        allow_shell=cfg.allow_shell,
+        confirm=tui.confirm if tui is not None else _confirm(args),
+        max_read_chars=cfg.max_read_chars,
+        max_write_chars=cfg.max_write_chars,
+        max_output_chars=cfg.max_tool_output_chars,
+        shell_timeout_sec=cfg.shell_timeout_sec,
+    )
+    session: ChatSession | None = None
+    try:
+        session = _new_session(cfg)
+        if tui is not None:
+            tui.start_status("Starting agent")
+        session.start()
+        if tui is not None:
+            tui.update_status("Getting ready")
+        session = _ensure_ready(
+            session,
+            cfg,
+            allow_auto_login=not args.no_auto_login,
+        )
+        if tui is not None:
+            tui.start_status("Getting ready")
+        session.new_chat()
+        session.set_modes()
+        if tui is not None:
+            tui.stop_status()
+            tui.banner(cfg)
+            return _chat_loop_tui(session, toolbox, cfg, args, workspace, tui)
+        return _chat_loop_plain(session, toolbox, cfg, args, workspace)
+    except ChatError as exc:
+        log.error("Chat error: %s", exc)
+        if exc.screenshot:
+            log.error("Screenshot: %s", exc.screenshot)
+        if toolbox.changed_files:
+            log.error("Files changed before the error: %s", ", ".join(toolbox.changed_files))
+        return 1
+    except (LoginRequired, HumanCheckRequired, BrowserError, UploadError) as exc:
+        log.error(str(exc))
+        return 1
+    except PlaywrightError as exc:
+        log.error("Browser automation failed: %s", exc)
+        log.error("Run `dscli doctor --headed` to inspect the page and selectors.")
+        return 1
+    except KeyboardInterrupt:
+        log.error("Interrupted.")
+        return 130
+    except Exception as exc:
+        if args.verbose:
+            log.exception("Unexpected error")
+        else:
+            log.error("Unexpected error: %s: %s", type(exc).__name__, exc)
+        return 1
+    finally:
+        if tui is not None:
+            tui.close()
+        if session is not None:
+            session.close()
+
+
+def cmd_run(args: argparse.Namespace, parser: argparse.ArgumentParser) -> int:
+    task = _read_task(args, parser)
+    ensure_config_file()
+    cfg = load_config()
+    cfg = _apply_run_config(cfg, args)
+
+    workspace = Path(args.workspace).expanduser() if args.workspace else Path.cwd()
+    try:
+        workspace = workspace.resolve(strict=True)
+    except FileNotFoundError:
+        log.error("Workspace does not exist: %s", workspace)
+        return 1
+    if not workspace.is_dir():
+        log.error("Workspace is not a directory: %s", workspace)
+        return 1
+
+    try:
+        attachments = collect_attachments(
+            args.file,
+            workspace,
+            max_count=cfg.max_attachments,
+            max_mb=cfg.max_attachment_mb,
+        )
+    except AttachmentError as exc:
+        log.error("Attachment error: %s", exc)
+        return 1
+
+    if args.dry_run:
+        prompt = build_initial_prompt(
+            task=task,
+            workspace=workspace,
+            attachments=attachments,
+            workspace_tree=workspace_preview(workspace),
+            allow_shell=cfg.allow_shell,
+            allow_outside=cfg.allow_outside,
+            max_steps=cfg.max_steps,
+        )
+        if not args.quiet:
+            log.info(
+                "Dry run: %d attachment(s), workspace %s, %d prompt characters.",
+                len(attachments),
+                workspace,
+                len(prompt),
+            )
+        print(prompt)
+        return 0
+
+    confirm = _confirm(args)
+    toolbox = Toolbox(
+        workspace,
+        allow_outside=cfg.allow_outside,
+        allow_shell=cfg.allow_shell,
+        confirm=confirm,
+        max_read_chars=cfg.max_read_chars,
+        max_write_chars=cfg.max_write_chars,
+        max_output_chars=cfg.max_tool_output_chars,
+        shell_timeout_sec=cfg.shell_timeout_sec,
+    )
+
+    session: ChatSession | None = None
+    outcome = None
+    try:
+        session = _new_session(cfg)
+        session.start()
+        session = _ensure_ready(
+            session, cfg, allow_auto_login=not args.no_auto_login
+        )
+        session.new_chat()
+        session.set_modes()
+        outcome = run_agent(
+            session=session,
+            config=cfg,
+            toolbox=toolbox,
+            task=task,
+            workspace=workspace,
+            attachments=attachments,
+            verbose=args.verbose,
+            quiet=args.quiet,
+        )
+    except ApprovalRequired as exc:
+        log.error("Approval required: %s", exc)
+        if toolbox.changed_files:
+            log.error("Files already changed: %s", ", ".join(toolbox.changed_files))
+        return 1
+    except ProtocolError as exc:
+        log.error("Model protocol error: %s", exc)
+        if toolbox.changed_files:
+            log.error("Files changed before the error: %s", ", ".join(toolbox.changed_files))
+        return 1
+    except ChatError as exc:
+        log.error("Chat error: %s", exc)
+        if exc.screenshot:
+            log.error("Screenshot: %s", exc.screenshot)
+        if toolbox.changed_files:
+            log.error("Files changed before the error: %s", ", ".join(toolbox.changed_files))
+        return 1
+    except (LoginRequired, HumanCheckRequired, BrowserError, UploadError) as exc:
+        log.error(str(exc))
+        return 1
+    except PlaywrightError as exc:
+        log.error("Browser automation failed: %s", exc)
+        log.error("Run `dscli doctor --headed` to inspect the page and selectors.")
+        return 1
+    except KeyboardInterrupt:
+        log.error("Interrupted.")
+        return 130
+    except Exception as exc:
+        if args.verbose:
+            log.exception("Unexpected error")
+        else:
+            log.error("Unexpected error: %s: %s", type(exc).__name__, exc)
+        return 1
+    finally:
+        if session is not None:
+            session.close()
+
+    if outcome is None:
+        return 1
+    final = outcome.final if outcome.final.endswith("\n") else outcome.final + "\n"
+    sys.stdout.write(final)
+    sys.stdout.flush()
+    if outcome.limit_reached:
+        log.warning("Stopped after the model-turn budget was exhausted. Raise --max-steps to continue.")
+        return 2
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    _utf8_stdio()
+    arguments = sys.argv[1:] if argv is None else argv
+    if not arguments:
+        arguments = ["chat"]
+    parser = build_parser()
+    args = parser.parse_args(arguments)
+    _setup_logging(bool(getattr(args, "verbose", False)), bool(getattr(args, "quiet", False)))
+    try:
+        if args.command == "login":
+            return cmd_login(args)
+        if args.command == "doctor":
+            return cmd_doctor(args)
+        if args.command == "config":
+            return cmd_config(args)
+        if args.command == "chat":
+            return cmd_chat(args)
+        if args.command == "run":
+            return cmd_run(args, parser)
+        parser.error(f"Unknown command: {args.command}")
+        return 2
+    except KeyboardInterrupt:
+        log.error("Interrupted.")
+        return 130
+    except (ApprovalRequired, BrowserError, ChatError, LoginRequired, HumanCheckRequired, UploadError) as exc:
+        log.error(str(exc))
+        return 1
+    except (AttachmentError, ValueError) as exc:
+        log.error(str(exc))
+        return 1
+    except PlaywrightError as exc:
+        log.error("Browser automation failed: %s", exc)
+        log.error("Run `dscli doctor --headed` to inspect the page and selectors.")
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())