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

copper_pilot_cli/copper_auth.py

@@ -0,0 +1,232 @@
+"""Browser device login and private credential persistence."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import hashlib
+import json
+import os
+import platform
+import re
+import socket
+import stat
+import tempfile
+import time
+import webbrowser
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+from copper_pilot_cli.copper_config import api_base_url, paths
+
+_STORE_VERSION = 1
+_KEY_PREFIX = "cf_live_"
+_FLOW_TOKEN_RE = re.compile(r"^[A-Za-z0-9._~-]{8,512}$")
+
+
+class AuthenticationError(RuntimeError):
+    """Authentication could not be completed."""
+
+
+@dataclass(frozen=True, slots=True)
+class DeviceCredential:
+    """Credential returned by CopperPilot's device login."""
+
+    api_key: str
+    fingerprint: str
+    base_url: str
+    issued_at: str | None = None
+    expires_at: str | None = None
+
+
+def _total_memory() -> int:
+    if os.name == "posix":
+        with contextlib.suppress(ValueError, OSError, AttributeError):
+            return int(os.sysconf("SC_PAGE_SIZE")) * int(os.sysconf("SC_PHYS_PAGES"))
+    return 0
+
+
+def safe_hostname() -> str:
+    """Return the same URL-safe hostname shape as the desktop client."""
+    value = re.sub(r"[^a-z0-9-]", "_", socket.gethostname().lower())
+    value = re.sub(r"_{2,}", "_", value).strip("_")[:50]
+    return value or "copper_pilot_client"
+
+
+def build_fingerprint() -> str:
+    """Build a stable, non-secret device fingerprint."""
+    signature = "||".join(
+        [
+            platform.system().lower(),
+            platform.machine().lower(),
+            str(_total_memory()),
+            platform.processor() or "unknown",
+        ]
+    )
+    return f"{safe_hostname()}_{hashlib.sha256(signature.encode()).hexdigest()}"
+
+
+def normalize_flow_token(value: object) -> str:
+    """Validate a device-login flow token before it enters a URL."""
+    token = str(value or "").strip()
+    if token.lower() in {"", "null", "undefined"} or not _FLOW_TOKEN_RE.fullmatch(token):
+        raise AuthenticationError("The device login flow token is invalid.")
+    return token
+
+
+def _private_dir(path: Path) -> None:
+    path.mkdir(parents=True, exist_ok=True)
+    if os.name != "nt":
+        path.chmod(stat.S_IRWXU)
+
+
+def save_credential(credential: DeviceCredential, target: Path | None = None) -> tuple[str, ...]:
+    """Atomically save a credential with dcode-equivalent file protections."""
+    destination = target or paths().auth
+    _private_dir(destination.parent)
+    payload = json.dumps(
+        {"version": _STORE_VERSION, "credential": asdict(credential)},
+        separators=(",", ":"),
+    ).encode()
+    warnings: list[str] = []
+    fd, temporary_name = tempfile.mkstemp(prefix="auth-", suffix=".tmp", dir=destination.parent)
+    temporary = Path(temporary_name)
+    try:
+        with os.fdopen(fd, "wb") as handle:
+            handle.write(payload)
+        if os.name != "nt":
+            temporary.chmod(stat.S_IRUSR | stat.S_IWUSR)
+        temporary.replace(destination)
+        if os.name != "nt":
+            destination.chmod(stat.S_IRUSR | stat.S_IWUSR)
+    except Exception:
+        with contextlib.suppress(OSError):
+            temporary.unlink()
+        raise
+    if os.name != "nt":
+        mode = stat.S_IMODE(destination.stat().st_mode)
+        if mode != 0o600:
+            warnings.append(f"Could not restrict {destination} to mode 0600.")
+    return tuple(warnings)
+
+
+def load_credential(target: Path | None = None) -> DeviceCredential | None:
+    """Load and validate the stored device credential."""
+    destination = target or paths().auth
+    try:
+        data = json.loads(destination.read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        return None
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise AuthenticationError(f"Credential store is unreadable: {destination}") from exc
+    if not isinstance(data, dict) or data.get("version") != _STORE_VERSION:
+        raise AuthenticationError("Credential store has an unsupported format.")
+    item = data.get("credential")
+    if not isinstance(item, dict):
+        raise AuthenticationError("Credential store has no device credential.")
+    credential = DeviceCredential(
+        api_key=str(item.get("api_key") or ""),
+        fingerprint=str(item.get("fingerprint") or ""),
+        base_url=str(item.get("base_url") or ""),
+        issued_at=item.get("issued_at"),
+        expires_at=item.get("expires_at"),
+    )
+    if not credential.api_key.startswith(_KEY_PREFIX) or not credential.fingerprint:
+        raise AuthenticationError("Stored CopperPilot credential is invalid.")
+    return credential
+
+
+def clear_credential(target: Path | None = None) -> bool:
+    """Delete the stored credential."""
+    destination = target or paths().auth
+    try:
+        destination.unlink()
+    except FileNotFoundError:
+        return False
+    return True
+
+
+async def validate_credential(credential: DeviceCredential) -> bool:
+    """Validate credential lifecycle status without logging secret content."""
+    async with httpx.AsyncClient(timeout=15) as client:
+        response = await client.post(
+            f"{credential.base_url}/api/copperpilot/analyze/token_limits",
+            headers={
+                "Authorization": f"Bearer {credential.api_key}",
+                "X-CopperPilot-Fingerprint": credential.fingerprint,
+            },
+        )
+    if response.status_code in {401, 403}:
+        return False
+    response.raise_for_status()
+    return True
+
+
+class DeviceLogin:
+    """Run CopperPilot's browser-based device login flow."""
+
+    def __init__(self, base_url: str | None = None, client_version: str = "0.1.0") -> None:
+        self.base_url = (base_url or api_base_url()).rstrip("/")
+        self.client_version = client_version
+
+    async def login(self, *, open_browser: bool = True) -> DeviceCredential:
+        """Start a flow, open the browser, and poll until ready."""
+        fingerprint = build_fingerprint()
+        endpoint = f"{self.base_url}/api/copperpilot/auth/api-keys-device-login-flow"
+        async with httpx.AsyncClient(timeout=30) as client:
+            response = await client.post(
+                endpoint,
+                json={
+                    "host_name": safe_hostname(),
+                    "fingerprint": fingerprint,
+                    "platform": platform.system().lower(),
+                    "client_version": self.client_version,
+                },
+            )
+            response.raise_for_status()
+            body = response.json()
+            token = normalize_flow_token(body.get("flow_token"))
+            if open_browser:
+                webbrowser.open(f"{self.base_url}/createKey?flow_token={quote(token)}")
+            started = time.monotonic()
+            expiry_seconds = min(
+                max(int(body.get("expires_in_seconds") or body.get("expires_in") or 300), 1),
+                900,
+            )
+            while time.monotonic() - started < expiry_seconds:
+                elapsed = time.monotonic() - started
+                delay = 0.3 if elapsed < 10 else 1.0
+                poll = await client.get(endpoint, params={"flow_token": token})
+                if poll.status_code == 200:
+                    result: dict[str, Any] = poll.json()
+                    key = str(result.get("api_key") or "")
+                    if result.get("status") == "ready" and key.startswith(_KEY_PREFIX):
+                        credential = DeviceCredential(
+                            api_key=key,
+                            fingerprint=fingerprint,
+                            base_url=self.base_url,
+                            issued_at=result.get("issued_at"),
+                            expires_at=result.get("expires_at"),
+                        )
+                        save_credential(credential)
+                        return credential
+                elif poll.status_code in {401, 410}:
+                    raise AuthenticationError("Device login expired or was rejected.")
+                elif poll.status_code == 409:
+                    pending = poll.json()
+                    if pending.get("error_code") not in {None, "FLOW_PENDING"}:
+                        raise AuthenticationError(
+                            str(pending.get("message") or "Device login failed.")
+                        )
+                    with contextlib.suppress(ValueError, TypeError, json.JSONDecodeError):
+                        retry = pending.get("retry_after_ms")
+                        if retry is not None:
+                            delay = max(0.2, min(float(retry) / 1000, 5))
+                else:
+                    poll.raise_for_status()
+                await asyncio.sleep(delay)
+        raise AuthenticationError("Device login timed out.")

copper_pilot_cli/copper_config.py

@@ -0,0 +1,62 @@
+"""CopperPilot CLI configuration and data paths."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from urllib.parse import urlparse
+
+DEFAULT_API_URL = "https://copperpilot.ai"
+APP_HOME_ENV = "COPPER_PILOT_CLI_HOME"
+API_URL_ENV = "COPPER_PILOT_API_URL"
+
+
+def normalize_base_url(value: str | None) -> str:
+    """Return a normalized HTTP(S) origin or an empty string."""
+    raw = (value or "").strip()
+    if not raw:
+        return ""
+    parsed = urlparse(raw)
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+        return ""
+    return f"{parsed.scheme}://{parsed.netloc}".rstrip("/")
+
+
+def app_home() -> Path:
+    """Return the private per-user CopperPilot CLI home."""
+    override = os.getenv(APP_HOME_ENV)
+    return Path(override).expanduser() if override else Path.home() / ".copper-pilot"
+
+
+def api_base_url() -> str:
+    """Return the configured API URL, defaulting to production."""
+    return normalize_base_url(os.getenv(API_URL_ENV)) or DEFAULT_API_URL
+
+
+@dataclass(frozen=True, slots=True)
+class AppPaths:
+    """Resolved application paths."""
+
+    home: Path
+    state: Path
+    auth: Path
+    sessions: Path
+    history: Path
+    logs: Path
+    recent_projects: Path
+
+
+def paths() -> AppPaths:
+    """Resolve application paths at call time for testability."""
+    home = app_home()
+    state = home / ".state"
+    return AppPaths(
+        home=home,
+        state=state,
+        auth=state / "auth.json",
+        sessions=state / "sessions.db",
+        history=state / "history.jsonl",
+        logs=state / "logs",
+        recent_projects=state / "recent-projects.json",
+    )

copper_pilot_cli/copper_features.py

@@ -0,0 +1,263 @@
+"""CopperPilot project skills, plans, attachments, and KiCad paste handling."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import httpx
+import yaml
+
+from copper_pilot_cli.copper_auth import DeviceCredential
+from copper_pilot_cli.copper_protocol import PlanContext, PlanTodo
+from copper_pilot_cli.copper_widgets import CompletionEntry
+
+MAX_LOCAL_SKILLS = 32
+MAX_SKILL_BYTES = 64 * 1024
+MAX_INSTRUCTIONS = 8_000
+MAX_DESCRIPTION = 500
+MAX_METADATA = 300
+MAX_SNIPPET_CHARS = 2_000_000
+SKILL_ID = re.compile(r"^[a-z0-9][a-z0-9-]*$")
+FRONTMATTER = re.compile(r"^---\r?\n([\s\S]*?)\r?\n---\r?\n?")
+KICAD_PREFIXES = (
+    "(lib_symbols",
+    "(kicad_pcb",
+    "(footprint",
+    "(symbol",
+    "(text",
+    "(version",
+    "(generator",
+    "(wire",
+    "(junction",
+    "(global_label",
+    "(net ",
+    "(net\t",
+    "(net\n",
+)
+
+
+@dataclass(frozen=True, slots=True)
+class LocalSkill:
+    id: str
+    label: str
+    description: str
+    required_inputs: str
+    artifact_outputs: str
+    instructions: str
+    path: str
+
+    def manifest_entry(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "label": self.label,
+            "slash": f"/{self.id}",
+            "category": "local",
+            "description": self.description,
+            "required_inputs": self.required_inputs,
+            "artifact_outputs": self.artifact_outputs,
+            "instructions": self.instructions,
+            "source": {
+                "type": "local",
+                "path": self.path,
+                "folder": str(Path(self.path).parent),
+            },
+        }
+
+    def command_entry(self) -> CompletionEntry:
+        return CompletionEntry(
+            name=f"/{self.id}",
+            description=f"Skill · {self.description}",
+            display_name=f"/{self.id}  [skill]",
+        )
+
+
+def _paragraph(body: str) -> str:
+    objective = re.search(
+        r"^##\s+Objective\s*\n+([\s\S]*?)(?:\n##\s|\n#+\s|$)",
+        body,
+        re.IGNORECASE | re.MULTILINE,
+    )
+    value = objective.group(1) if objective else body
+    paragraphs = [
+        re.sub(r"\s+", " ", chunk).strip()
+        for chunk in re.split(r"\n\s*\n", value)
+        if chunk.strip() and not chunk.lstrip().startswith("#")
+    ]
+    return (paragraphs[0] if paragraphs else "Local CopperPilot skill")[:MAX_DESCRIPTION]
+
+
+def scan_local_skills(workspace: Path) -> tuple[list[LocalSkill], list[str]]:
+    """Read bounded `.copperpilot/skills/<id>/SKILL.md` entries."""
+    root = workspace / ".copperpilot" / "skills"
+    skills: list[LocalSkill] = []
+    diagnostics: list[str] = []
+    if not root.is_dir():
+        return skills, diagnostics
+    for folder in sorted(root.iterdir())[:MAX_LOCAL_SKILLS]:
+        identifier = folder.name.lower()
+        file = folder / "SKILL.md"
+        if not folder.is_dir() or not SKILL_ID.fullmatch(identifier) or not file.is_file():
+            diagnostics.append(f"Ignored invalid local skill folder: {folder.name}")
+            continue
+        if file.stat().st_size > MAX_SKILL_BYTES:
+            diagnostics.append(f"Ignored oversized local skill: {identifier}")
+            continue
+        text = file.read_text(encoding="utf-8")
+        match = FRONTMATTER.match(text)
+        if not match:
+            diagnostics.append(f"Missing YAML frontmatter: {identifier}")
+            continue
+        try:
+            metadata = yaml.safe_load(match.group(1)) or {}
+        except yaml.YAMLError:
+            diagnostics.append(f"Invalid YAML frontmatter: {identifier}")
+            continue
+        if not isinstance(metadata, dict):
+            diagnostics.append(f"Invalid skill metadata: {identifier}")
+            continue
+        required = str(metadata.get("required_inputs") or "").strip()[:MAX_METADATA]
+        outputs = str(metadata.get("artifact_outputs") or "").strip()[:MAX_METADATA]
+        body = text[match.end() :].strip()
+        if not required or not outputs or not body:
+            diagnostics.append(f"Incomplete local skill: {identifier}")
+            continue
+        heading = re.search(r"^#\s+(.+)$", body, re.MULTILINE)
+        label = (
+            re.sub(r"^skill:\s*", "", heading.group(1), flags=re.IGNORECASE).strip()
+            if heading
+            else identifier.replace("-", " ").title()
+        )
+        skills.append(
+            LocalSkill(
+                id=identifier,
+                label=label,
+                description=_paragraph(body),
+                required_inputs=required,
+                artifact_outputs=outputs,
+                instructions=(
+                    body + "\n\n## Local skill helper scripts\nHelper scripts must remain inside "
+                    "this skill folder and use the normal file and shell tools."
+                )[:MAX_INSTRUCTIONS],
+                path=file.relative_to(workspace).as_posix(),
+            )
+        )
+    return skills, diagnostics
+
+
+async def resolve_skill_manifest(
+    credential: DeviceCredential,
+    skills: list[LocalSkill],
+    *,
+    cache_key: str | None = None,
+) -> dict[str, Any]:
+    """Merge local skill metadata through the hosted manifest endpoint."""
+    async with httpx.AsyncClient(timeout=30) as client:
+        response = await client.post(
+            f"{credential.base_url}/api/copperpilot/skills/manifest",
+            headers={
+                "Authorization": f"Bearer {credential.api_key}",
+                "X-CopperPilot-Fingerprint": credential.fingerprint,
+            },
+            json={
+                "local_manifest": {
+                    "version": 1,
+                    "skills": [skill.manifest_entry() for skill in skills],
+                },
+                "client_cache_key": cache_key,
+            },
+        )
+        response.raise_for_status()
+        return response.json()
+
+
+def parse_plan(path: Path, workspace: Path) -> PlanContext:
+    """Parse a `.copperpilot/plans/*.plan.md` artifact."""
+    resolved = path.resolve()
+    plans = (workspace / ".copperpilot" / "plans").resolve()
+    if plans not in resolved.parents or not resolved.name.endswith(".plan.md"):
+        raise ValueError("Plan must be a .copperpilot/plans/*.plan.md file.")
+    text = resolved.read_text(encoding="utf-8")
+    match = FRONTMATTER.match(text)
+    metadata: dict[str, Any] = {}
+    if match:
+        loaded = yaml.safe_load(match.group(1)) or {}
+        metadata = loaded if isinstance(loaded, dict) else {}
+    body = text[match.end() :].strip() if match else text.strip()
+    todos: list[PlanTodo] = []
+    for row in metadata.get("todos") or []:
+        if isinstance(row, dict) and row.get("id") and row.get("content"):
+            status = str(row.get("status") or "open").lower()
+            todos.append(
+                PlanTodo(
+                    id=str(row["id"]),
+                    content=str(row["content"]),
+                    status=status if status in {"open", "running", "done"} else "open",
+                )
+            )
+    overall = str(metadata.get("overall_status") or "open").lower()
+    return PlanContext(
+        file_path=resolved.relative_to(workspace).as_posix(),
+        name=str(metadata.get("name") or resolved.name.removesuffix(".plan.md")),
+        overview=str(metadata.get("overview") or ""),
+        overall_status=overall if overall in {"open", "running", "done"} else "open",
+        todos=todos,
+        body=body,
+    )
+
+
+def looks_like_kicad_snippet(text: str) -> bool:
+    """Validate a bounded KiCad S-expression in one pass."""
+    if not text or len(text) > MAX_SNIPPET_CHARS:
+        return False
+    stripped = text.strip()
+    if not stripped.startswith(KICAD_PREFIXES):
+        return False
+    depth = 0
+    quoted = False
+    escaped = False
+    for char in stripped:
+        if escaped:
+            escaped = False
+        elif char == "\\" and quoted:
+            escaped = True
+        elif char == '"':
+            quoted = not quoted
+        elif not quoted and char == "(":
+            depth += 1
+        elif not quoted and char == ")":
+            depth -= 1
+            if depth < 0:
+                return False
+    return depth == 0 and not quoted
+
+
+def path_first_attachment(path: Path, workspace: Path) -> dict[str, Any]:
+    """Describe a workspace attachment without embedding file bytes."""
+    resolved = path.expanduser().resolve()
+    root = workspace.resolve()
+    if resolved != root and root not in resolved.parents:
+        raise ValueError("Attachment must be inside the workspace.")
+    if not resolved.is_file():
+        raise FileNotFoundError(resolved)
+    return {
+        "type": "file",
+        "path": resolved.relative_to(root).as_posix(),
+        "name": resolved.name,
+        "size": resolved.stat().st_size,
+    }
+
+
+def encode_runtime_context(
+    *,
+    attachments: list[dict[str, Any]] | None = None,
+    snippet: str | None = None,
+) -> dict[str, Any] | None:
+    payload: dict[str, Any] = {}
+    if attachments:
+        payload["attachments"] = attachments
+    if snippet and looks_like_kicad_snippet(snippet):
+        payload["kicad_snippet"] = {"format": "sexpr", "content": snippet}
+    return payload or None