cyborgy 0.1.0__tar.gz

cyborgy-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+prune tests

cyborgy-0.1.0/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: cyborgy
+Version: 0.1.0
+Summary: Extend the claude and codex CLIs: skills marketplace, memory, and extension APIs via the Cyborgy MCP.
+Author: Kizuna Intelligence
+Project-URL: Homepage, https://github.com/kizuna-intelligence/cyborgy
+Project-URL: Repository, https://github.com/kizuna-intelligence/cyborgy
+Keywords: cyborgy,codex,claude,mcp,skills,agents
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+Requires-Dist: mcp>=1.2
+Requires-Dist: pynacl>=1.5
+
+# Cyborgy CLI
+
+`cyborgy` extends coding-agent CLIs such as Claude Code and Codex with the
+Cyborgy MCP, workspace roles, skills, memory, extension APIs, and temporary
+tunnels.
+
+This package provides:
+
+- `cyborgy`: the main CLI.
+- `cyborgy-mcp`: the MCP server used by supported coding agents.
+- `cyborgy-dev` and `cyborgy-mcp-dev`: development-environment entry points.
+
+## Install
+
+```bash
+pip install cyborgy
+```
+
+## Basic usage
+
+```bash
+cyborgy login
+cyborgy mcp install --target codex
+cyborgy codex exec "summarize this repository"
+```
+
+The CLI stores login state locally, installs the Cyborgy MCP configuration into
+the current repository, and syncs the skills assigned to that workspace.
+
+## Status
+
+This is an alpha package. The public CLI surface is expected to evolve with the
+Cyborgy service.

cyborgy-0.1.0/README.md

@@ -0,0 +1,33 @@
+# Cyborgy CLI
+
+`cyborgy` extends coding-agent CLIs such as Claude Code and Codex with the
+Cyborgy MCP, workspace roles, skills, memory, extension APIs, and temporary
+tunnels.
+
+This package provides:
+
+- `cyborgy`: the main CLI.
+- `cyborgy-mcp`: the MCP server used by supported coding agents.
+- `cyborgy-dev` and `cyborgy-mcp-dev`: development-environment entry points.
+
+## Install
+
+```bash
+pip install cyborgy
+```
+
+## Basic usage
+
+```bash
+cyborgy login
+cyborgy mcp install --target codex
+cyborgy codex exec "summarize this repository"
+```
+
+The CLI stores login state locally, installs the Cyborgy MCP configuration into
+the current repository, and syncs the skills assigned to that workspace.
+
+## Status
+
+This is an alpha package. The public CLI surface is expected to evolve with the
+Cyborgy service.

cyborgy-0.1.0/cyborgy/__init__.py

@@ -0,0 +1,3 @@
+"""Cyborgy CLI + MCP — extend the claude and codex CLIs."""
+
+__version__ = "0.1.0"

cyborgy-0.1.0/cyborgy/api.py

@@ -0,0 +1,311 @@
+"""Thin HTTP client over the Cyborgy backend. Shared by the CLI and the MCP."""
+from __future__ import annotations
+
+import httpx
+
+from . import config
+
+
+class ApiError(RuntimeError):
+    pass
+
+
+def _media_body(url, question, data, filename, mime_type) -> dict:
+    body: dict = {"url": url or "", "question": question}
+    if data:
+        body["data"] = data
+    if filename:
+        body["filename"] = filename
+    if mime_type:
+        body["mime_type"] = mime_type
+    return body
+
+
+class Api:
+    def __init__(self, token: str | None = None, base_url: str | None = None) -> None:
+        self.base_url = (base_url or config.api_url()).rstrip("/")
+        self.token = token if token is not None else config.get_token()
+
+    def _headers(self) -> dict:
+        return {"Authorization": f"Bearer {self.token}"} if self.token else {}
+
+    def _req(self, method: str, path: str, **kw) -> httpx.Response:
+        kw.setdefault("timeout", 120)
+        resp = httpx.request(method, f"{self.base_url}{path}", headers=self._headers(), **kw)
+        if resp.status_code >= 400:
+            raise ApiError(f"{method} {path} -> {resp.status_code}: {resp.text}")
+        return resp
+
+    # --- auth (device flow) ---
+    def device_start(self, name: str = "", host: str = "") -> dict:
+        return self._req("POST", "/auth/device/start", json={"name": name, "host": host}).json()
+
+    def device_token(self, device_code: str) -> httpx.Response:
+        # caller inspects status (428 = keep polling); don't raise here.
+        return httpx.post(f"{self.base_url}/auth/device/token", json={"device_code": device_code}, timeout=30)
+
+    def me(self) -> dict:
+        return self._req("GET", "/auth/me").json()
+
+    # --- ephemeral tunnels ---
+    def tunnel_config(self) -> dict:
+        return self._req("POST", "/me/tunnel/config").json()
+
+    # --- skills ---
+    def search_skills(self, q: str | None = None, tag: str | None = None) -> list[dict]:
+        params = {k: v for k, v in {"q": q, "tag": tag}.items() if v}
+        return self._req("GET", "/skills", params=params).json()
+
+    def get_skill(self, skill_id: str) -> dict:
+        return self._req("GET", f"/skills/{skill_id}").json()
+
+    def get_skill_files(self, skill_id: str) -> dict:
+        return self._req("GET", f"/skills/{skill_id}/files").json()
+
+    def create_skill(self, payload: dict) -> dict:
+        return self._req("POST", "/skills", json=payload).json()
+
+    def update_skill(self, skill_id: str, patch: dict) -> dict:
+        return self._req("PUT", f"/skills/{skill_id}", json=patch).json()
+
+    def put_skill_files(self, skill_id: str, files: list[dict], message: str = "update") -> dict:
+        return self._req("PUT", f"/skills/{skill_id}/files", json={"files": files, "message": message}).json()
+
+    def delete_skill(self, skill_id: str) -> None:
+        self._req("DELETE", f"/skills/{skill_id}")
+
+    # --- my skills ---
+    def my_skills(self) -> list[dict]:
+        return self._req("GET", "/me/skills").json()
+
+    def my_owned(self) -> list[dict]:
+        return self._req("GET", "/me/skills/owned").json()
+
+    def add_favorite(self, skill_id: str) -> None:
+        self._req("PUT", f"/me/skills/{skill_id}")
+
+    # --- api catalog ---
+    def list_apis(self, q: str | None = None, tag: str | None = None) -> list[dict]:
+        params = {k: v for k, v in {"q": q, "tag": tag}.items() if v}
+        return self._req("GET", "/apis", params=params).json()
+
+    def get_api(self, api_id: str) -> dict:
+        return self._req("GET", f"/apis/{api_id}").json()
+
+    def my_apis(self) -> list[dict]:
+        return self._req("GET", "/me/apis").json()
+
+    def my_owned_apis(self) -> list[dict]:
+        return self._req("GET", "/me/apis/owned").json()
+
+    def create_api(self, payload: dict) -> dict:
+        return self._req("POST", "/apis", json=payload).json()
+
+    def update_api(self, api_id: str, patch: dict) -> dict:
+        return self._req("PUT", f"/apis/{api_id}", json=patch).json()
+
+    def add_api_favorite(self, api_id: str) -> None:
+        self._req("PUT", f"/me/apis/{api_id}")
+
+    def call_api(self, path: str, body: dict) -> dict:
+        """Invoke an API by its backend path (e.g. /media/audio/ask)."""
+        return self._req("POST", path, json=body).json()
+
+    def api_job(self, path: str, job_id: str) -> dict:
+        """Fetch an async API job by the API's backend path."""
+        return self._req("GET", f"{path.rstrip('/')}/{job_id}").json()
+
+    # --- memory ---
+    def memory_add(self, text: str, metadata: dict | None = None) -> dict:
+        return self._req("POST", "/memory", json={"text": text, "metadata": metadata or {}}).json()
+
+    def memory_search(self, q: str, limit: int = 10) -> list[dict]:
+        return self._req("GET", "/memory/search", params={"q": q, "limit": limit}).json()
+
+    # --- roles & workspaces ---
+    def list_roles(self) -> list[dict]:
+        return self._req("GET", "/me/roles").json()
+
+    def create_role(self, payload: dict) -> dict:
+        return self._req("POST", "/me/roles", json=payload).json()
+
+    def get_role(self, role_id: str) -> dict:
+        return self._req("GET", f"/me/roles/{role_id}").json()
+
+    def update_role(self, role_id: str, patch: dict) -> dict:
+        role = self.get_role(role_id)
+        payload = {
+            "name": role.get("name", ""),
+            "description": role.get("description", ""),
+            "parent_role_ids": role.get("parent_role_ids") or [],
+            "skill_ids": role.get("skill_ids") or [],
+        }
+        payload.update(patch)
+        return self._req("PUT", f"/me/roles/{role_id}", json=payload).json()
+
+    def delete_role(self, role_id: str) -> None:
+        self._req("DELETE", f"/me/roles/{role_id}")
+
+    def get_workspace(self, machine: str, path: str) -> dict:
+        return self._req("GET", "/me/workspace", params={"machine": machine, "path": path}).json()
+
+    def set_workspace(self, machine: str, path: str, role_ids: list[str], supervisor_role_ids: list[str] | None = None,
+                      code_review_role_ids: list[str] | None = None) -> dict:
+        current = None
+        if supervisor_role_ids is None:
+            current = self.get_workspace(machine, path)
+            supervisor_role_ids = current.get("supervisor_role_ids") or []
+        if code_review_role_ids is None:
+            current = current or self.get_workspace(machine, path)
+            code_review_role_ids = current.get("code_review_role_ids") or []
+        return self._req("PUT", "/me/workspace",
+                         json={"machine_id": machine, "path": path, "role_ids": role_ids,
+                               "supervisor_role_ids": supervisor_role_ids,
+                               "code_review_role_ids": code_review_role_ids}).json()
+
+    def list_workspaces(self) -> list[dict]:
+        return self._req("GET", "/me/workspaces").json()
+
+    def list_repository_role_bindings(self) -> list[dict]:
+        return self._req("GET", "/me/repository-role-bindings").json()
+
+    def set_repository_role_binding(self, github_repository: str, role_ids: list[str],
+                                    supervisor_role_ids: list[str] | None = None,
+                                    code_review_role_ids: list[str] | None = None) -> dict:
+        current = None
+        if supervisor_role_ids is None:
+            current = next((b for b in self.list_repository_role_bindings()
+                            if b.get("github_repository") == github_repository), {})
+            supervisor_role_ids = current.get("supervisor_role_ids") or []
+        if code_review_role_ids is None:
+            current = current or next((b for b in self.list_repository_role_bindings()
+                                       if b.get("github_repository") == github_repository), {})
+            code_review_role_ids = current.get("code_review_role_ids") or []
+        return self._req("PUT", "/me/repository-role-binding",
+                         json={"github_repository": github_repository, "role_ids": role_ids,
+                               "supervisor_role_ids": supervisor_role_ids,
+                               "code_review_role_ids": code_review_role_ids}).json()
+
+    def resolve_workspace(self, machine: str, path: str, github_repository: str | None = None) -> dict:
+        params = {"machine": machine, "path": path}
+        if github_repository:
+            params["github_repository"] = github_repository
+        return self._req("GET", "/me/workspace/resolve", params=params).json()
+
+    # --- AI chat / coordination ---
+    def ai_chat_post(self, channel: str, message: str, agent_id: str = "") -> dict:
+        return self._req("POST", "/me/ai-chat/messages",
+                         json={"channel": channel, "message": message, "agent_id": agent_id}).json()
+
+    def ai_chat_list(self, channel: str = "work", since: str = "", until: str = "", limit: int = 100) -> list[dict]:
+        params = {"channel": channel, "limit": limit}
+        if since:
+            params["since"] = since
+        if until:
+            params["until"] = until
+        return self._req("GET", "/me/ai-chat/messages", params=params).json()
+
+    # --- worker (remote task execution) ---
+    def worker_register(self, name: str, host: str, root: str = "", dirs: list[str] | None = None,
+                        convos: list[dict] | None = None, accounts: list[dict] | None = None,
+                        public_key: str = "", models: dict | None = None) -> dict:
+        return self._req("POST", "/worker/register",
+                         json={"name": name, "host": host, "root": root, "dirs": dirs or [],
+                               "convos": convos or [], "accounts": accounts or [], "public_key": public_key,
+                               "models": models or {}}).json()
+
+    def worker_poll(self, worker_id: str) -> list[dict]:
+        return self._req("GET", "/worker/poll", params={"worker_id": worker_id}, timeout=40).json()
+
+    # --- cloud login (browser/code re-auth driven from the web) ---
+    def cloud_login_get(self, cl_id: str) -> dict:
+        return self._req("GET", f"/worker/cloud-login/{cl_id}").json()
+
+    def cloud_login_update(self, cl_id: str, *, status: str | None = None, url: str | None = None,
+                           code: str | None = None, needs_code: bool | None = None, message: str | None = None) -> None:
+        body: dict = {}
+        for k, v in {"status": status, "url": url, "code": code, "needs_code": needs_code, "message": message}.items():
+            if v is not None:
+                body[k] = v
+        self._req("POST", f"/worker/cloud-login/{cl_id}", json=body)
+
+    # --- viewer (files shown in the web) ---
+    def push_view(self, session_id: str, name: str, mime: str, data: str) -> dict:
+        return self._req("POST", "/me/views",
+                         json={"session_id": session_id, "name": name, "mime": mime, "data": data}).json()
+
+    def list_views(self, session_id: str | None = None) -> list[dict]:
+        params = {"session_id": session_id} if session_id else {}
+        return self._req("GET", "/me/views", params=params).json()
+
+    def session_output(self, session_id: str, *, text: str | None = None,
+                       review_text: str | None = None,
+                       status: str | None = None, exit_code: int | None = None,
+                       claude_session_id: str | None = None,
+                       review_session_id: str | None = None, review_status: str | None = None,
+                       review_feedback: str | None = None, review_round: int | None = None,
+                       completion_summary: str | None = None, completion_detail: str | None = None,
+                       completion_status: str | None = None) -> None:
+        body: dict = {}
+        if text is not None:
+            body["text"] = text
+        if review_text is not None:
+            body["review_text"] = review_text
+        if status is not None:
+            body["status"] = status
+        if exit_code is not None:
+            body["exit_code"] = exit_code
+        if claude_session_id is not None:
+            body["claude_session_id"] = claude_session_id
+        if review_session_id is not None:
+            body["review_session_id"] = review_session_id
+        if review_status is not None:
+            body["review_status"] = review_status
+        if review_feedback is not None:
+            body["review_feedback"] = review_feedback
+        if review_round is not None:
+            body["review_round"] = review_round
+        if completion_summary is not None:
+            body["completion_summary"] = completion_summary
+        if completion_detail is not None:
+            body["completion_detail"] = completion_detail
+        if completion_status is not None:
+            body["completion_status"] = completion_status
+        self._req("POST", f"/worker/sessions/{session_id}/output", json=body)
+
+    def notify_work_complete(self, session_id: str, one_line_summary: str, detailed_summary: str,
+                             status: str = "complete") -> None:
+        self.session_output(
+            session_id,
+            completion_summary=one_line_summary,
+            completion_detail=detailed_summary,
+            completion_status=status,
+        )
+
+    # --- media ---
+    def ask_audio(self, url: str | None, question: str, *, data: str | None = None,
+                  filename: str | None = None, mime_type: str | None = None) -> dict:
+        return self._req("POST", "/media/audio/ask", json=_media_body(url, question, data, filename, mime_type)).json()
+
+    def ask_video(self, url: str | None, question: str, *, data: str | None = None,
+                  filename: str | None = None, mime_type: str | None = None) -> dict:
+        return self._req("POST", "/media/video/ask", json=_media_body(url, question, data, filename, mime_type)).json()
+
+    # --- generative media ---
+    def image_gen(self, prompt: str, n: int = 1, aspect_ratio: str | None = None) -> dict:
+        return self._req("POST", "/media/image/generate",
+                         json={"prompt": prompt, "n": n, "aspect_ratio": aspect_ratio or ""}).json()
+
+    def tts(self, text: str, voice: str | None = None, language: str | None = None) -> dict:
+        return self._req("POST", "/media/tts",
+                         json={"text": text, "voice": voice or "", "language": language or ""}).json()
+
+    def music_gen(self, prompt: str, negative_prompt: str | None = None, seconds: int = 30) -> dict:
+        return self._req("POST", "/media/music/generate",
+                         json={"prompt": prompt, "negative_prompt": negative_prompt or "", "seconds": seconds}).json()
+
+    def video_gen(self, prompt: str, seconds: int = 8) -> dict:
+        return self._req("POST", "/media/video/generate", json={"prompt": prompt, "seconds": seconds}).json()
+
+    def media_job(self, job_id: str) -> dict:
+        return self._req("GET", f"/media/jobs/{job_id}").json()

cyborgy-0.1.0/cyborgy/auth.py

@@ -0,0 +1,48 @@
+"""Device-authorization login, Claude-CLI style."""
+from __future__ import annotations
+
+import sys
+import time
+import webbrowser
+
+from . import config
+from .api import Api
+
+
+def login(open_browser: bool = True, name: str = "", host: str = "") -> dict:
+    api = Api(token=None)
+    start = api.device_start(name, host)  # name/host let the web approve this worker per-worker
+    url = start["verification_uri_complete"]
+
+    print("\n  To sign in, open this URL and approve the code:\n")
+    print(f"      {start['verification_uri']}")
+    print(f"      code: {start['user_code']}\n")
+    if open_browser:
+        try:
+            webbrowser.open(url)
+        except Exception:  # noqa: BLE001 - headless is fine
+            pass
+
+    interval = start.get("interval", 5)
+    deadline = time.time() + start.get("expires_in", 900)
+    print("  Waiting for approval", end="", flush=True)
+    while time.time() < deadline:
+        resp = api.device_token(start["device_code"])
+        if resp.status_code == 200:
+            token = resp.json()["access_token"]
+            config.set_token(token)
+            me = Api(token=token).me()
+            print(f"\n  ✓ Logged in as {me.get('email') or me.get('uid')}\n")
+            return me
+        if resp.status_code == 428:  # authorization_pending
+            print(".", end="", flush=True)
+            time.sleep(interval)
+            continue
+        print(f"\n  login failed: {resp.status_code} {resp.text}", file=sys.stderr)
+        break
+    raise SystemExit("login timed out or failed")
+
+
+def ensure_login() -> None:
+    if config.get_token() is None:
+        login()