copper-pilot-cli 0.1.1__py3-none-any.whl

copper_pilot_cli/copper_graph.py

@@ -0,0 +1,178 @@
+"""Local checkpointed graph that projects the hosted agent into dcode sessions."""
+
+from __future__ import annotations
+
+import json
+import operator
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Annotated, Any, TypedDict
+
+from langchain_core.messages import AIMessage, ToolMessage
+from langgraph.config import get_stream_writer
+from langgraph.graph import END, START, StateGraph
+from langgraph.graph.message import add_messages
+
+from copper_pilot_cli.copper_protocol import EventKind
+from copper_pilot_cli.langchain import CopperPilotAgent
+from copper_pilot_cli.sessions import get_checkpointer
+
+
+class CopperState(TypedDict, total=False):
+    messages: Annotated[list[Any], add_messages]
+    copper_mode: str
+    copper_events: Annotated[list[dict[str, Any]], operator.add]
+
+
+class CopperGraphRuntime:
+    """Own one compiled transport graph and its SQLite checkpointer."""
+
+    def __init__(
+        self,
+        graph: Any,
+        checkpointer_context: Any,
+        agent: CopperPilotAgent,
+    ) -> None:
+        self.graph = graph
+        self._checkpointer_context = checkpointer_context
+        self.agent = agent
+
+    async def aclose(self) -> None:
+        await self._checkpointer_context.__aexit__(None, None, None)
+
+    def config(self, thread_id: str, workspace: Path) -> dict[str, Any]:
+        return {
+            "configurable": {"thread_id": thread_id},
+            "metadata": {
+                "agent_name": "copper-pilot",
+                "cwd": str(workspace.resolve()),
+            },
+        }
+
+    async def astream(self, values: dict[str, Any], config: dict[str, Any]) -> Any:
+        async for item in self.graph.astream(
+            values,
+            config=config,
+            stream_mode=["messages", "updates", "custom"],
+            subgraphs=True,
+        ):
+            yield item
+
+    async def aget_state(self, config: dict[str, Any]) -> Any:
+        return await self.graph.aget_state(config)
+
+    async def aupdate_state(
+        self,
+        config: dict[str, Any],
+        values: dict[str, Any] | None,
+        *,
+        as_node: str | None = None,
+    ) -> Any:
+        return await self.graph.aupdate_state(config, values, as_node=as_node)
+
+    async def acancel(self) -> None:
+        await self.agent.acancel()
+
+
+@asynccontextmanager
+async def create_copper_graph(agent: CopperPilotAgent) -> Any:
+    """Compile a one-node, no-local-model graph using dcode's checkpointer."""
+    checkpointer_context = get_checkpointer()
+    checkpointer = await checkpointer_context.__aenter__()
+
+    async def hosted_node(state: CopperState) -> dict[str, Any]:
+        writer = get_stream_writer()
+        additions: list[Any] = []
+        recorded_events: list[dict[str, Any]] = []
+        text: list[str] = []
+        pending_tools: dict[str, str] = {}
+        async for event in agent.astream_events_raw({"messages": state["messages"]}):
+            projected = {
+                "type": f"copper.{event.kind.value}",
+                "data": event.data.model_dump(mode="json")
+                if hasattr(event.data, "model_dump")
+                else event.data,
+                "title": event.title,
+                "turn_id": event.turn_id,
+                "sequence": event.sequence,
+                "resume_attempt": event.resume_attempt,
+            }
+            writer(projected)
+            recorded_events.append(projected)
+            if event.kind is EventKind.TEXT:
+                text.append(str(event.data))
+            elif event.kind is EventKind.TOOL_REQUEST:
+                tool = event.data
+                additions.append(
+                    AIMessage(
+                        content="".join(text),
+                        tool_calls=[
+                            {
+                                "id": tool.tool_call_id,
+                                "name": tool.tool_name,
+                                "args": tool.arguments,
+                                "type": "tool_call",
+                            }
+                        ],
+                    )
+                )
+                text.clear()
+                pending_tools[tool.tool_call_id] = tool.tool_name
+            elif event.kind is EventKind.TOOL_RESULT:
+                payload = event.data
+                result = payload["result"]
+                is_error = isinstance(result, dict) and (
+                    bool(result.get("error"))
+                    or (isinstance(result.get("exit_code"), int) and result["exit_code"] != 0)
+                )
+                rejected = isinstance(result, dict) and result.get("rejected") is True
+                if isinstance(result, dict):
+                    content = result.get("error") or result.get("result", result)
+                    artifact = {
+                        key: result[key] for key in ("exit_code", "truncated") if key in result
+                    }
+                else:
+                    content = result
+                    artifact = {}
+                additions.append(
+                    ToolMessage(
+                        content=(
+                            content
+                            if isinstance(content, (str, list))
+                            else json.dumps(content, default=str)
+                        ),
+                        tool_call_id=payload["tool_call_id"],
+                        name=payload["tool_name"],
+                        status="error" if is_error else "success",
+                        artifact=artifact or None,
+                        additional_kwargs={"copper_rejected": rejected},
+                    )
+                )
+                pending_tools.pop(payload["tool_call_id"], None)
+        for tool_id, tool_name in pending_tools.items():
+            additions.append(
+                ToolMessage(
+                    content="Tool stream ended before a result was returned.",
+                    tool_call_id=tool_id,
+                    name=tool_name,
+                    status="error",
+                )
+            )
+        if text or not additions:
+            additions.append(AIMessage(content="".join(text)))
+        return {
+            "messages": additions,
+            "copper_mode": state.get("copper_mode", agent.mode.value),
+            "copper_events": recorded_events,
+        }
+
+    graph = StateGraph(CopperState)  # ty: ignore[invalid-argument-type]
+    graph.add_node("copper_pilot", hosted_node)
+    graph.add_edge(START, "copper_pilot")
+    graph.add_edge("copper_pilot", END)
+    compiled = graph.compile(checkpointer=checkpointer)
+    runtime = CopperGraphRuntime(compiled, checkpointer_context, agent)
+    try:
+        yield runtime
+    finally:
+        await runtime.aclose()

copper_pilot_cli/copper_hooks.py

@@ -0,0 +1,49 @@
+"""Workspace hook support routed through the normal approval broker."""
+
+from __future__ import annotations
+
+import json
+import uuid
+from pathlib import Path
+from typing import Any, Literal
+
+from copper_pilot_cli.copper_protocol import ToolRequest
+from copper_pilot_cli.copper_tools import LocalToolBroker
+
+HookEvent = Literal["before_turn", "after_turn"]
+
+
+class HookRunner:
+    """Load bounded project hooks and execute them as approved shell tools."""
+
+    def __init__(self, workspace: Path, broker: LocalToolBroker) -> None:
+        self.workspace = workspace
+        self.broker = broker
+
+    def commands(self, event: HookEvent) -> list[str]:
+        path = self.workspace / ".copperpilot" / "hooks.json"
+        try:
+            value = json.loads(path.read_text(encoding="utf-8"))
+        except (FileNotFoundError, OSError, json.JSONDecodeError):
+            return []
+        raw = value.get(event) if isinstance(value, dict) else None
+        if not isinstance(raw, list):
+            return []
+        return [str(command)[:4_000] for command in raw[:16] if str(command).strip()]
+
+    async def run(self, event: HookEvent) -> list[dict[str, Any]]:
+        results: list[dict[str, Any]] = []
+        for command in self.commands(event):
+            result = await self.broker.execute(
+                ToolRequest(
+                    tool_call_id=f"hook-{event}-{uuid.uuid4()}",
+                    tool_name="bash",
+                    arguments={
+                        "command": command,
+                        "description": f"CopperPilot {event.replace('_', ' ')} hook",
+                        "background": False,
+                    },
+                )
+            )
+            results.append(result if isinstance(result, dict) else {"result": result})
+        return results

copper_pilot_cli/copper_main.py

@@ -0,0 +1,345 @@
+"""CopperPilot CLI entrypoint."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+import httpx
+from langchain_core.messages import HumanMessage
+from rich.console import Console
+from rich.prompt import Confirm
+
+from copper_pilot_cli._version import __version__
+from copper_pilot_cli.copper_app import CopperPilotApp
+from copper_pilot_cli.copper_auth import (
+    AuthenticationError,
+    DeviceLogin,
+    clear_credential,
+    load_credential,
+    validate_credential,
+)
+from copper_pilot_cli.copper_graph import create_copper_graph
+from copper_pilot_cli.copper_preferences import saved_approval_mode, shell_auto_allow_settings
+from copper_pilot_cli.copper_protocol import CopperMode, EventKind
+from copper_pilot_cli.copper_tools import ApprovalMode, LocalToolBroker
+from copper_pilot_cli.copper_workspace import (
+    canonical_workspace,
+    discover_workspace,
+    remember_workspace,
+)
+from copper_pilot_cli.diagnostics import configure_diagnostics
+from copper_pilot_cli.langchain import CopperPilotAgent
+from copper_pilot_cli.sessions import delete_thread, generate_thread_id, list_threads
+
+console = Console()
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(
+        prog="copper-pilot",
+        description="CopperPilot hosted agent in the terminal.",
+        epilog="Subcommands: copper-pilot auth [login|logout|status]; "
+        "copper-pilot threads list|delete.",
+    )
+    result.add_argument(
+        "workspace",
+        nargs="?",
+        default=".",
+        help="Workspace directory (default: current directory)",
+    )
+    result.add_argument("-m", "--message", help="Message to send")
+    result.add_argument(
+        "-r",
+        "--resume",
+        nargs="?",
+        const="recent",
+        help="Resume a thread; omit the id to continue the most recent one",
+    )
+    result.add_argument(
+        "-n",
+        "--non-interactive",
+        action="store_true",
+        help="Run without the Textual UI (requires --message)",
+    )
+    result.add_argument(
+        "--quiet",
+        action="store_true",
+        help="Hide status and reasoning lines in headless streaming output",
+    )
+    result.add_argument(
+        "--no-stream",
+        action="store_true",
+        help="Print the final assistant message instead of streaming",
+    )
+    result.add_argument("--json", action="store_true", help="Emit JSON events")
+    result.add_argument(
+        "--mode",
+        choices=[item.value for item in CopperMode],
+        default="agent",
+        help="Hosted chat mode (default: agent)",
+    )
+    result.add_argument(
+        "-y",
+        "--auto-approve",
+        action="store_true",
+        help="Permit routine local writes; still prompt for unknown actions",
+    )
+    result.add_argument(
+        "--yolo",
+        action="store_true",
+        help="Permit local side effects without prompting",
+    )
+    result.add_argument("--version", action="version", version=__version__)
+    result.set_defaults(command=None)
+    return result
+
+
+def command_parser(command: str) -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(
+        prog=f"copper-pilot {command}",
+        description=(
+            "Device login for the hosted CopperPilot agent."
+            if command == "auth"
+            else "List or delete CopperPilot chat threads."
+        ),
+    )
+    result.set_defaults(workspace=".", message=None, command=command)
+    if command == "auth":
+        result.add_argument(
+            "action",
+            nargs="?",
+            choices=["login", "logout", "status"],
+            default="status",
+            help="login opens a browser; logout clears credentials; status is default",
+        )
+        return result
+    thread_sub = result.add_subparsers(dest="thread_action", required=True)
+    listing = thread_sub.add_parser("list", help="List threads for this workspace")
+    listing.add_argument(
+        "--all",
+        action="store_true",
+        help="Include threads from other workspaces",
+    )
+    listing.add_argument(
+        "--limit",
+        type=int,
+        default=20,
+        help="Maximum rows to print (default: 20)",
+    )
+    deleting = thread_sub.add_parser("delete", help="Delete a thread")
+    deleting.add_argument("thread_id", help="Thread identifier to delete")
+    deleting.add_argument(
+        "-y",
+        "--yes",
+        action="store_true",
+        help="Do not prompt for confirmation",
+    )
+    return result
+
+
+async def _auth_command(action: str) -> int:
+    if action == "logout":
+        console.print(
+            "Logged out." if clear_credential() else "Already logged out.",
+            markup=False,
+        )
+        return 0
+    if action == "status":
+        credential = load_credential()
+        console.print(
+            f"Authenticated to {credential.base_url}."
+            if credential
+            else "Not authenticated. Run `copper-pilot auth login`.",
+            markup=False,
+        )
+        return 0 if credential else 1
+    console.print("Opening CopperPilot login in your browser…", markup=False)
+    credential = await DeviceLogin(client_version=__version__).login()
+    console.print(f"Authenticated to {credential.base_url}.", markup=False)
+    return 0
+
+
+async def _threads_command(args: argparse.Namespace, workspace: Path) -> int:
+    if args.thread_action == "delete":
+        if not args.yes:
+            if not sys.stdin.isatty():
+                console.print(
+                    "Use --yes to confirm deletion in non-interactive mode.",
+                    markup=False,
+                )
+                return 2
+            if not Confirm.ask(f"Delete chat {args.thread_id}?"):
+                return 0
+        deleted = await delete_thread(args.thread_id)
+        console.print("Deleted." if deleted else "Thread not found.", markup=False)
+        return 0 if deleted else 1
+    rows = await list_threads(
+        limit=args.limit,
+        include_message_count=True,
+        cwd=None if args.all else str(workspace),
+    )
+    for row in rows:
+        console.print(
+            f"{row['thread_id']}  {row.get('updated_at') or ''}  "
+            f"{row.get('message_count', 0)} messages  {row.get('initial_prompt') or ''}",
+            markup=False,
+            highlight=False,
+        )
+    return 0
+
+
+async def _credential() -> Any:
+    credential = load_credential()
+    if credential is not None:
+        try:
+            if await validate_credential(credential):
+                return credential
+        except httpx.HTTPError as exc:
+            raise AuthenticationError(f"Could not reach CopperPilot: {exc}") from exc
+        clear_credential()
+        console.print("Your CopperPilot login expired; signing in again.", markup=False)
+    if not sys.stdin.isatty():
+        raise AuthenticationError("Login required; run `copper-pilot auth login` interactively.")
+    console.print("Opening CopperPilot login in your browser…", markup=False)
+    return await DeviceLogin(client_version=__version__).login()
+
+
+async def _resolve_thread(resume: str | None, workspace: Path) -> str:
+    if resume and resume != "recent":
+        return resume
+    if resume == "recent":
+        rows = await list_threads(limit=1, cwd=str(workspace))
+        if rows:
+            return rows[0]["thread_id"]
+    return generate_thread_id()
+
+
+async def _headless(
+    runtime: Any,
+    workspace: Path,
+    thread_id: str,
+    message: str,
+    args: argparse.Namespace,
+) -> int:
+    config = runtime.config(thread_id, workspace)
+    events: list[dict[str, Any]] = []
+    failed = False
+    async for item in runtime.astream(
+        {"messages": [HumanMessage(content=message)], "copper_mode": args.mode},
+        config,
+    ):
+        _namespace, stream_mode, data = item
+        if stream_mode != "custom" or not isinstance(data, dict):
+            continue
+        events.append(data)
+        kind = str(data.get("type") or "").removeprefix("copper.")
+        payload = data.get("data")
+        if kind == EventKind.ERROR.value:
+            failed = True
+        elif kind == EventKind.FINAL.value and isinstance(payload, dict):
+            failed = failed or payload.get("success") is False or bool(payload.get("error"))
+        if args.no_stream:
+            continue
+        if args.json:
+            print(json.dumps({"type": kind, "data": payload, "title": data.get("title")}))
+        elif kind == EventKind.TEXT.value:
+            print(str(payload), end="", flush=True)
+        elif not args.quiet and kind in {
+            EventKind.STATUS.value,
+            EventKind.REASONING.value,
+        }:
+            console.print(f"\n{payload}", style="dim", markup=False, highlight=False)
+
+    state = await runtime.aget_state(config)
+    messages = (getattr(state, "values", {}) or {}).get("messages", [])
+    assistant_content = str(messages[-1].content) if messages else ""
+    if args.no_stream:
+        if args.json:
+            print(
+                json.dumps(
+                    {
+                        "messages": [{"role": "assistant", "content": assistant_content}],
+                        "events": events,
+                    }
+                )
+            )
+        else:
+            console.print(assistant_content, markup=False, highlight=False)
+    elif not args.json:
+        print()
+    return 1 if failed else 0
+
+
+async def async_main(args: argparse.Namespace) -> int:
+    workspace = canonical_workspace(args.workspace)
+    if args.command == "auth":
+        return await _auth_command(args.action)
+    if args.command == "threads":
+        return await _threads_command(args, workspace)
+    credential = await _credential()
+    context = discover_workspace(workspace)
+    remember_workspace(context)
+    approval = (
+        ApprovalMode.YOLO
+        if args.yolo
+        else ApprovalMode.AUTO
+        if args.auto_approve
+        else saved_approval_mode()
+    )
+    normal_shell, dangerous_shell = shell_auto_allow_settings()
+    broker = LocalToolBroker(
+        workspace,
+        mode=approval,
+        always_allow_shell_commands=normal_shell,
+        always_allow_dangerous_shell_commands=dangerous_shell,
+    )
+    thread_id = await _resolve_thread(args.resume, workspace)
+    agent = CopperPilotAgent(
+        workspace,
+        credential=credential,
+        conversation_id=thread_id,
+        mode=CopperMode(args.mode),
+        tool_broker=broker,
+    )
+    if args.non_interactive or (args.message and not sys.stdout.isatty()):
+        if not args.message:
+            raise ValueError("--message is required in non-interactive mode.")
+        async with create_copper_graph(agent) as runtime:
+            return await _headless(runtime, workspace, thread_id, args.message, args)
+    async with create_copper_graph(agent) as runtime:
+        app = CopperPilotApp(
+            runtime,
+            broker,
+            workspace,
+            thread_id,
+            mode=CopperMode(args.mode),
+            initial_message=args.message,
+        )
+        await app.run_async()
+    return 0
+
+
+def cli_main() -> None:
+    """Run the CopperPilot command."""
+    configure_diagnostics()
+    argv = sys.argv[1:]
+    args = (
+        command_parser(argv[0]).parse_args(argv[1:])
+        if argv and argv[0] in {"auth", "threads"}
+        else parser().parse_args(argv)
+    )
+    try:
+        raise SystemExit(asyncio.run(async_main(args)))
+    except (AuthenticationError, FileNotFoundError, NotADirectoryError, ValueError) as exc:
+        console.print(f"copper-pilot: {exc}", style="red", markup=False, highlight=False)
+        raise SystemExit(2) from exc
+    except (RuntimeError, httpx.HTTPError) as exc:
+        console.print(f"copper-pilot: {exc}", style="red", markup=False, highlight=False)
+        raise SystemExit(1) from exc
+    except KeyboardInterrupt:
+        raise SystemExit(130) from None

copper_pilot_cli/copper_preferences.py

@@ -0,0 +1,85 @@
+"""Small non-secret CLI preference store."""
+
+from __future__ import annotations
+
+import json
+import stat
+from pathlib import Path
+from typing import Any
+
+from copper_pilot_cli.copper_config import paths
+from copper_pilot_cli.copper_tools import ApprovalMode
+
+YOLO_ACK_VERSION = 1
+AUTO_NOTICE_VERSION = 1
+
+
+def _path() -> Path:
+    return paths().state / "config.json"
+
+
+def load_preferences() -> dict[str, Any]:
+    try:
+        value = json.loads(_path().read_text(encoding="utf-8"))
+    except (FileNotFoundError, OSError, json.JSONDecodeError):
+        return {}
+    return value if isinstance(value, dict) else {}
+
+
+def save_preferences(value: dict[str, Any]) -> None:
+    destination = _path()
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    destination.parent.chmod(stat.S_IRWXU)
+    temporary = destination.with_suffix(".tmp")
+    temporary.write_text(json.dumps(value, indent=2), encoding="utf-8")
+    temporary.chmod(stat.S_IRUSR | stat.S_IWUSR)
+    temporary.replace(destination)
+
+
+def saved_approval_mode() -> ApprovalMode:
+    raw = load_preferences().get("approval_mode")
+    return ApprovalMode.AUTO if raw == ApprovalMode.AUTO.value else ApprovalMode.MANUAL
+
+
+def save_approval_mode(mode: ApprovalMode) -> None:
+    value = load_preferences()
+    value["approval_mode"] = (
+        ApprovalMode.AUTO.value if mode is ApprovalMode.AUTO else ApprovalMode.MANUAL.value
+    )
+    save_preferences(value)
+
+
+def shell_auto_allow_settings() -> tuple[bool, bool]:
+    """Return CLI-owned normal and dangerous shell Auto settings."""
+    value = load_preferences()
+    return (
+        value.get("always_allow_shell_commands", True) is True,
+        value.get("always_allow_dangerous_shell_commands", False) is True,
+    )
+
+
+def save_shell_auto_allow_settings(*, normal: bool, dangerous: bool) -> None:
+    value = load_preferences()
+    value["always_allow_shell_commands"] = normal
+    value["always_allow_dangerous_shell_commands"] = dangerous
+    save_preferences(value)
+
+
+def auto_notice_acknowledged() -> bool:
+    return load_preferences().get("auto_notice_version") == AUTO_NOTICE_VERSION
+
+
+def acknowledge_auto_notice() -> None:
+    value = load_preferences()
+    value["auto_notice_version"] = AUTO_NOTICE_VERSION
+    save_preferences(value)
+
+
+def yolo_acknowledged() -> bool:
+    return load_preferences().get("yolo_ack_version") == YOLO_ACK_VERSION
+
+
+def acknowledge_yolo() -> None:
+    value = load_preferences()
+    value["yolo_ack_version"] = YOLO_ACK_VERSION
+    save_preferences(value)