ghlike 0.1.0__tar.gz

ghlike-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ghlike contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ghlike-0.1.0/PKG-INFO

@@ -0,0 +1,195 @@
+Metadata-Version: 2.4
+Name: ghlike
+Version: 0.1.0
+Summary: Like (star) repos on GitHub with your existing browser session — no tokens, no API keys.
+Author: ghlike contributors
+License: MIT
+Project-URL: Homepage, https://github.com/686f6c61/ghlike-py
+Project-URL: Repository, https://github.com/686f6c61/ghlike-py
+Project-URL: Issues, https://github.com/686f6c61/ghlike-py/issues
+Project-URL: Changelog, https://github.com/686f6c61/ghlike-py/releases
+Keywords: github,star,like,cli,browser-session
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ghlike
+
+**Star GitHub repos with your browser session — no tokens. / Da estrellas
+en GitHub con la sesión de tu navegador — sin tokens.**
+
+[English](#english) · [Español](#español)
+
+This is the Python CLI of the [ghlike project](https://github.com/686f6c61/ghlike)
+(like-button widget + browser extension + Node CLI live there). Zero
+dependencies: the CDP WebSocket client is implemented on the standard
+library, so the whole package audits in one sitting.
+
+---
+
+# English
+
+## What it does
+
+`ghlike owner/repo` stars a GitHub repository using the login session
+already active in your browser. No `gh auth login`, no personal access
+tokens, no OAuth: if you're logged into GitHub in Brave, Chrome, Chromium,
+Edge, Vivaldi or Opera (native or snap installs), it just works.
+
+How: it finds the browser profile with your github.com session → copies the
+**encrypted** cookie store to a throwaway profile → opens your own browser
+headless with a private debug port → clicks the real Star button (GitHub
+handles its own CSRF) → verifies → kills the browser and deletes the
+profile. Cookies are never decrypted and never leave your machine.
+
+## Install
+
+```bash
+pipx install ghlike        # or: pip install --user ghlike
+```
+
+Requires Python ≥ 3.9 and a Chromium-family browser with a github.com
+session. Firefox is not supported (no CDP).
+
+## CLI
+
+```bash
+ghlike owner/repo            # star (idempotent — tells you if already starred)
+ghlike https://github.com/o/r  # full URLs work
+ghlike owner/repo -c         # check current state only
+ghlike owner/repo -u         # unstar
+ghlike owner/repo --toggle   # flip
+ghlike --list                # github.com sessions found in your browsers
+ghlike --browser brave o/r   # force one browser (strict)
+ghlike o/r --json            # machine-readable output
+```
+
+Exit codes: `0` ok (incl. nothing-to-do) · `1` generic error · `2` no
+github.com session · `3` repo not found.
+
+JSON example:
+
+```bash
+$ ghlike cli/cli --check --json
+{"repo":"cli/cli","user":"you","browser":"Brave","profile":"Default",
+ "before":false,"action":"check","after":false,"changed":false}
+```
+
+## Library
+
+```python
+from ghlike import star, unstar, check, toggle
+
+star("vercel/next.js")                 # -> {"repo": ..., "changed": True, ...}
+state = check("vercel/next.js")        # -> {"repo": ..., "after": True/False, ...}
+unstar("vercel/next.js", browser="brave")
+toggle("vercel/next.js")
+```
+
+Exceptions: `NoSessionError`, `RepoNotFoundError`, `GhlikeError`.
+
+## Limitations
+
+- Chromium-family browsers only; Firefox is not supported (no CDP).
+- Each operation takes ~8–12 s (headless browser + page load). That's the
+  price of the no-token approach.
+- Depends on GitHub's Star button; if the markup changes, one selector line
+  fixes it (`STATE_JS` in `src/ghlike/core.py`).
+
+## Development
+
+```bash
+PYTHONPATH=src python3 -m ghlike.cli --list
+python -m pip wheel . --no-deps --no-build-isolation -w dist
+```
+
+Publishing is automated: push a git tag / create a GitHub Release `vX.Y.Z`
+and `.github/workflows/publish-pypi.yml` publishes to PyPI via
+[Trusted Publishing](https://docs.pypi.org/trusted-publishers/) (no
+secrets). Versions live in `pyproject.toml` and `src/ghlike/__init__.py`.
+
+License: MIT.
+
+---
+
+# Español
+
+## Qué hace
+
+`ghlike owner/repo` da una estrella a un repositorio de GitHub usando la
+sesión ya iniciada en tu navegador. Sin `gh auth login`, sin personal access
+tokens, sin OAuth: si estás logueado en GitHub en Brave, Chrome, Chromium,
+Edge, Vivaldi u Opera (nativo o snap), funciona directamente.
+
+Cómo: busca el perfil del navegador con tu sesión de github.com → copia la
+tienda de cookies **cifrada** a un perfil desechable → abre tu propio
+navegador en modo invisible con un puerto de depuración privado → pulsa el
+botón de Star real (GitHub gestiona su propio CSRF) → verifica → cierra el
+navegador y borra el perfil. Las cookies nunca se descifran ni salen de tu
+máquina.
+
+## Instalación
+
+```bash
+pipx install ghlike        # o: pip install --user ghlike
+```
+
+Requiere Python ≥ 3.9 y un navegador de la familia Chromium con sesión de
+github.com. Firefox no está soportado (sin CDP).
+
+## CLI
+
+```bash
+ghlike owner/repo            # dar star (idempotente)
+ghlike https://github.com/o/r  # URLs completas valen
+ghlike owner/repo -c         # solo consultar estado
+ghlike owner/repo -u         # quitar star
+ghlike owner/repo --toggle   # invertir
+ghlike --list                # sesiones de GitHub detectadas
+ghlike --browser brave o/r   # forzar un navegador (estricto)
+ghlike o/r --json            # salida para scripts
+```
+
+Códigos de salida: `0` ok (también "nada que hacer") · `1` error genérico ·
+`2` sin sesión de github.com · `3` repo no encontrado.
+
+## Librería
+
+```python
+from ghlike import star, unstar, check, toggle
+
+star("vercel/next.js")                 # -> {"repo": ..., "changed": True, ...}
+state = check("vercel/next.js")        # -> {"repo": ..., "after": True/False, ...}
+unstar("vercel/next.js", browser="brave")
+```
+
+Excepciones: `NoSessionError`, `RepoNotFoundError`, `GhlikeError`.
+
+## Limitaciones
+
+- Solo navegadores Chromium; Firefox no (sin CDP).
+- Cada operación tarda ~8–12 s (navegador invisible + carga). Es el precio
+  del enfoque sin tokens.
+- Depende del botón de Star de GitHub; si cambia el markup, se arregla con
+  una línea (`STATE_JS` en `src/ghlike/core.py`).
+
+## Desarrollo
+
+```bash
+PYTHONPATH=src python3 -m ghlike.cli --list
+python -m pip wheel . --no-deps --no-build-isolation -w dist
+```
+
+La publicación es automática: crea un Release `vX.Y.Z` en GitHub y
+`.github/workflows/publish-pypi.yml` publica en PyPI con Trusted Publishing
+(sin secrets). Las versiones viven en `pyproject.toml` y
+`src/ghlike/__init__.py`.
+
+Licencia: MIT.

ghlike-0.1.0/README.md

@@ -0,0 +1,173 @@
+# ghlike
+
+**Star GitHub repos with your browser session — no tokens. / Da estrellas
+en GitHub con la sesión de tu navegador — sin tokens.**
+
+[English](#english) · [Español](#español)
+
+This is the Python CLI of the [ghlike project](https://github.com/686f6c61/ghlike)
+(like-button widget + browser extension + Node CLI live there). Zero
+dependencies: the CDP WebSocket client is implemented on the standard
+library, so the whole package audits in one sitting.
+
+---
+
+# English
+
+## What it does
+
+`ghlike owner/repo` stars a GitHub repository using the login session
+already active in your browser. No `gh auth login`, no personal access
+tokens, no OAuth: if you're logged into GitHub in Brave, Chrome, Chromium,
+Edge, Vivaldi or Opera (native or snap installs), it just works.
+
+How: it finds the browser profile with your github.com session → copies the
+**encrypted** cookie store to a throwaway profile → opens your own browser
+headless with a private debug port → clicks the real Star button (GitHub
+handles its own CSRF) → verifies → kills the browser and deletes the
+profile. Cookies are never decrypted and never leave your machine.
+
+## Install
+
+```bash
+pipx install ghlike        # or: pip install --user ghlike
+```
+
+Requires Python ≥ 3.9 and a Chromium-family browser with a github.com
+session. Firefox is not supported (no CDP).
+
+## CLI
+
+```bash
+ghlike owner/repo            # star (idempotent — tells you if already starred)
+ghlike https://github.com/o/r  # full URLs work
+ghlike owner/repo -c         # check current state only
+ghlike owner/repo -u         # unstar
+ghlike owner/repo --toggle   # flip
+ghlike --list                # github.com sessions found in your browsers
+ghlike --browser brave o/r   # force one browser (strict)
+ghlike o/r --json            # machine-readable output
+```
+
+Exit codes: `0` ok (incl. nothing-to-do) · `1` generic error · `2` no
+github.com session · `3` repo not found.
+
+JSON example:
+
+```bash
+$ ghlike cli/cli --check --json
+{"repo":"cli/cli","user":"you","browser":"Brave","profile":"Default",
+ "before":false,"action":"check","after":false,"changed":false}
+```
+
+## Library
+
+```python
+from ghlike import star, unstar, check, toggle
+
+star("vercel/next.js")                 # -> {"repo": ..., "changed": True, ...}
+state = check("vercel/next.js")        # -> {"repo": ..., "after": True/False, ...}
+unstar("vercel/next.js", browser="brave")
+toggle("vercel/next.js")
+```
+
+Exceptions: `NoSessionError`, `RepoNotFoundError`, `GhlikeError`.
+
+## Limitations
+
+- Chromium-family browsers only; Firefox is not supported (no CDP).
+- Each operation takes ~8–12 s (headless browser + page load). That's the
+  price of the no-token approach.
+- Depends on GitHub's Star button; if the markup changes, one selector line
+  fixes it (`STATE_JS` in `src/ghlike/core.py`).
+
+## Development
+
+```bash
+PYTHONPATH=src python3 -m ghlike.cli --list
+python -m pip wheel . --no-deps --no-build-isolation -w dist
+```
+
+Publishing is automated: push a git tag / create a GitHub Release `vX.Y.Z`
+and `.github/workflows/publish-pypi.yml` publishes to PyPI via
+[Trusted Publishing](https://docs.pypi.org/trusted-publishers/) (no
+secrets). Versions live in `pyproject.toml` and `src/ghlike/__init__.py`.
+
+License: MIT.
+
+---
+
+# Español
+
+## Qué hace
+
+`ghlike owner/repo` da una estrella a un repositorio de GitHub usando la
+sesión ya iniciada en tu navegador. Sin `gh auth login`, sin personal access
+tokens, sin OAuth: si estás logueado en GitHub en Brave, Chrome, Chromium,
+Edge, Vivaldi u Opera (nativo o snap), funciona directamente.
+
+Cómo: busca el perfil del navegador con tu sesión de github.com → copia la
+tienda de cookies **cifrada** a un perfil desechable → abre tu propio
+navegador en modo invisible con un puerto de depuración privado → pulsa el
+botón de Star real (GitHub gestiona su propio CSRF) → verifica → cierra el
+navegador y borra el perfil. Las cookies nunca se descifran ni salen de tu
+máquina.
+
+## Instalación
+
+```bash
+pipx install ghlike        # o: pip install --user ghlike
+```
+
+Requiere Python ≥ 3.9 y un navegador de la familia Chromium con sesión de
+github.com. Firefox no está soportado (sin CDP).
+
+## CLI
+
+```bash
+ghlike owner/repo            # dar star (idempotente)
+ghlike https://github.com/o/r  # URLs completas valen
+ghlike owner/repo -c         # solo consultar estado
+ghlike owner/repo -u         # quitar star
+ghlike owner/repo --toggle   # invertir
+ghlike --list                # sesiones de GitHub detectadas
+ghlike --browser brave o/r   # forzar un navegador (estricto)
+ghlike o/r --json            # salida para scripts
+```
+
+Códigos de salida: `0` ok (también "nada que hacer") · `1` error genérico ·
+`2` sin sesión de github.com · `3` repo no encontrado.
+
+## Librería
+
+```python
+from ghlike import star, unstar, check, toggle
+
+star("vercel/next.js")                 # -> {"repo": ..., "changed": True, ...}
+state = check("vercel/next.js")        # -> {"repo": ..., "after": True/False, ...}
+unstar("vercel/next.js", browser="brave")
+```
+
+Excepciones: `NoSessionError`, `RepoNotFoundError`, `GhlikeError`.
+
+## Limitaciones
+
+- Solo navegadores Chromium; Firefox no (sin CDP).
+- Cada operación tarda ~8–12 s (navegador invisible + carga). Es el precio
+  del enfoque sin tokens.
+- Depende del botón de Star de GitHub; si cambia el markup, se arregla con
+  una línea (`STATE_JS` en `src/ghlike/core.py`).
+
+## Desarrollo
+
+```bash
+PYTHONPATH=src python3 -m ghlike.cli --list
+python -m pip wheel . --no-deps --no-build-isolation -w dist
+```
+
+La publicación es automática: crea un Release `vX.Y.Z` en GitHub y
+`.github/workflows/publish-pypi.yml` publica en PyPI con Trusted Publishing
+(sin secrets). Las versiones viven en `pyproject.toml` y
+`src/ghlike/__init__.py`.
+
+Licencia: MIT.

ghlike-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ghlike"
+version = "0.1.0"
+description = "Like (star) repos on GitHub with your existing browser session — no tokens, no API keys."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "ghlike contributors" }]
+keywords = ["github", "star", "like", "cli", "browser-session"]
+classifiers = [
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development",
+]
+# Cero dependencias a proposito: el paquete toca sesiones del navegador y
+# debe poder auditarse por completo.
+
+[project.urls]
+Homepage = "https://github.com/686f6c61/ghlike-py"
+Repository = "https://github.com/686f6c61/ghlike-py"
+Issues = "https://github.com/686f6c61/ghlike-py/issues"
+Changelog = "https://github.com/686f6c61/ghlike-py/releases"
+
+[project.scripts]
+ghlike = "ghlike.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

ghlike-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ghlike-0.1.0/src/ghlike/__init__.py

@@ -0,0 +1,5 @@
+"""ghlike: da likes (stars) en GitHub con la sesion de tu navegador, sin tokens."""
+
+__version__ = "0.1.0"
+
+from .core import GhlikeError, NoSessionError, RepoNotFoundError, check, run, star, toggle, unstar  # noqa: F401

ghlike-0.1.0/src/ghlike/browsers.py

@@ -0,0 +1,182 @@
+"""Detección de navegadores Chromium, sus perfiles y la sesión de GitHub dentro.
+
+Funciona con instalaciones nativas y empaquetadas (snap en Linux). No se
+descifra nada: solo se comprueba qué perfil tiene cookies de github.com y se
+copia la tienda tal cual a un directorio temporal que el propio navegador
+sabrá abrir.
+"""
+from __future__ import annotations
+
+import glob
+import os
+import shutil
+import sqlite3
+import tempfile
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+SESSION_COOKIES = ("user_session", "__Host-user_session_same_site", "logged_in", "_gh_sess")
+
+
+@dataclass
+class Browser:
+    name: str
+    label: str
+    exe_candidates: List[str] = field(default_factory=list)
+    root_globs: List[str] = field(default_factory=list)
+
+
+BROWSERS = [
+    Browser("brave", "Brave",
+            ["/snap/bin/brave", "/usr/bin/brave-browser", "/usr/bin/brave",
+             "/usr/local/bin/brave-browser", "/opt/brave.com/brave/brave-browser",
+             "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+             r"C:\Program Files\BraveSoftware\Brave-Browser\Application\brave.exe",
+             r"C:\Program Files (x86)\BraveSoftware\Brave-Browser\Application\brave.exe"],
+            ["~/.config/BraveSoftware/Brave-Browser",
+             "~/snap/brave/*/.config/BraveSoftware/Brave-Browser"]),
+    Browser("chrome", "Google Chrome",
+            ["/usr/bin/google-chrome", "/usr/bin/google-chrome-stable",
+             "/usr/bin/google-chrome-beta", "/opt/google/chrome/chrome",
+             "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+             r"C:\Program Files\Google\Chrome\Application\chrome.exe",
+             r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe"],
+            ["~/.config/google-chrome", "~/snap/google-chrome/*/.config/google-chrome"]),
+    Browser("chromium", "Chromium",
+            ["/snap/bin/chromium", "/usr/bin/chromium", "/usr/bin/chromium-browser",
+             "/Applications/Chromium.app/Contents/MacOS/Chromium",
+             r"C:\Program Files\Chromium\Application\chrome.exe"],
+            ["~/.config/chromium", "~/snap/chromium/*/.config/chromium"]),
+    Browser("edge", "Microsoft Edge",
+            ["/usr/bin/microsoft-edge", "/usr/bin/microsoft-edge-stable",
+             r"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe"],
+            ["~/.config/microsoft-edge"]),
+    Browser("vivaldi", "Vivaldi",
+            ["/usr/bin/vivaldi", "/usr/bin/vivaldi-stable",
+             "/Applications/Vivaldi.app/Contents/MacOS/Vivaldi"],
+            ["~/.config/vivaldi"]),
+    Browser("opera", "Opera",
+            ["/usr/bin/opera", "/usr/lib/x86_64-linux-gnu/opera/opera"],
+            ["~/.config/opera"]),
+]
+
+
+@dataclass
+class SessionInfo:
+    browser: Browser
+    exe: str
+    profile_dir: str       # ruta absoluta del perfil (".../Default", ".../Profile 1")
+    profile_name: str      # "Default", "Profile 1", ...
+    root_dir: str          # ruta del navegador (contiene "Local State")
+    cookie_count: int
+
+
+def resolve_exe(browser: Browser) -> Optional[str]:
+    for cand in browser.exe_candidates:
+        p = os.path.expanduser(cand)
+        if os.path.isfile(p) and os.access(p, os.X_OK):
+            return p
+        which = shutil.which(os.path.basename(cand)) if not os.path.isabs(cand) or os.sep not in cand else None
+        if which:
+            return which
+    which = shutil.which(browser.name)
+    return which
+
+
+def _profile_dirs(root: str) -> List[str]:
+    dirs = [d for d in glob.glob(os.path.join(root, "Default")) +
+            glob.glob(os.path.join(root, "Profile *")) if os.path.isdir(d)]
+    dirs.sort(key=lambda d: os.path.getmtime(os.path.join(d, "Cookies"))
+              if os.path.exists(os.path.join(d, "Cookies")) else 0, reverse=True)
+    return dirs
+
+
+def github_cookie_count(profile_dir: str) -> int:
+    db = os.path.join(profile_dir, "Cookies")
+    if not os.path.exists(db):
+        return 0
+    try:
+        con = sqlite3.connect(f"file:{db}?immutable=1", uri=True)
+        try:
+            marks = ",".join("?" * len(SESSION_COOKIES))
+            return con.execute(
+                f"SELECT COUNT(*) FROM cookies WHERE host_key LIKE '%github.com' "
+                f"AND name IN ({marks})", SESSION_COOKIES).fetchone()[0]
+        finally:
+            con.close()
+    except sqlite3.Error:
+        return 0
+
+
+def _expand_roots(browser: Browser) -> List[str]:
+    roots: List[str] = []
+    seen = set()
+    for pattern in browser.root_globs:
+        for r in glob.glob(os.path.expanduser(pattern)):
+            real = os.path.realpath(r)
+            if real in seen:
+                continue
+            seen.add(real)
+            if os.path.isdir(r):
+                roots.append(r)
+    roots.sort(key=lambda r: _newest_cookie_mtime(r), reverse=True)
+    return roots
+
+
+def _newest_cookie_mtime(root: str) -> float:
+    best = 0.0
+    for d in _profile_dirs(root):
+        cookies = os.path.join(d, "Cookies")
+        if os.path.exists(cookies):
+            best = max(best, os.path.getmtime(cookies))
+    return best
+
+
+def find_sessions(preferred: Optional[str] = None) -> List[SessionInfo]:
+    """Perfiles con sesión de GitHub.
+
+    Sin `preferred` escanea todos los navegadores soportados. Con `preferred`,
+    SOLO ese navegador: forzar uno y caer a otro en silencio seria engañoso.
+    """
+    if preferred:
+        order = [b for b in BROWSERS if b.name == preferred.lower()]
+        if not order:
+            return []
+    else:
+        order = list(BROWSERS)
+    found: List[SessionInfo] = []
+    for browser in order:
+        exe = resolve_exe(browser)
+        if not exe:
+            continue
+        for root in _expand_roots(browser):
+            for profile in _profile_dirs(root):
+                count = github_cookie_count(profile)
+                if count:
+                    found.append(SessionInfo(browser, exe, profile,
+                                             os.path.basename(profile), root, count))
+    return found
+
+
+# Ficheros mínimos que hacen viva una sesión en un user-data-dir nuevo.
+_PROFILE_FILES = ("Cookies", "Cookies-wal", "Cookies-shm", "Preferences")
+_ROOT_FILES = ("Local State",)
+
+
+def copy_session(session: SessionInfo) -> str:
+    """Copia la sesión a un user-data-dir temporal visible en $HOME.
+
+    Debe ser visible (sin punto inicial) porque los navegadores snap solo
+    tienen permiso de escritura sobre rutas no ocultas del home.
+    """
+    tmp = tempfile.mkdtemp(prefix="ghlike-", dir=os.path.expanduser("~"))
+    os.makedirs(os.path.join(tmp, session.profile_name), exist_ok=True)
+    for f in _PROFILE_FILES:
+        src = os.path.join(session.profile_dir, f)
+        if os.path.exists(src):
+            shutil.copy2(src, os.path.join(tmp, session.profile_name, f))
+    for f in _ROOT_FILES:
+        src = os.path.join(session.root_dir, f)
+        if os.path.exists(src):
+            shutil.copy2(src, os.path.join(tmp, f))
+    return tmp

ghlike-0.1.0/src/ghlike/cdp.py

@@ -0,0 +1,76 @@
+"""Cliente CDP (Chrome DevTools Protocol) mínimo sobre el WebSocket propio."""
+from __future__ import annotations
+
+import json
+import time
+import urllib.error
+import urllib.request
+from typing import Any, Dict, Optional
+from urllib.parse import urlparse
+
+from .ws import WebSocket
+
+
+class CdpError(RuntimeError):
+    pass
+
+
+def http_json(port: int, path: str, method: str = "GET") -> Dict[str, Any]:
+    req = urllib.request.Request(f"http://127.0.0.1:{port}{path}", method=method)
+    with urllib.request.urlopen(req, timeout=10) as resp:
+        return json.loads(resp.read().decode())
+
+
+def wait_for_cdp(port: int, timeout: float = 20.0) -> bool:
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        try:
+            http_json(port, "/json/version")
+            return True
+        except (urllib.error.URLError, OSError):
+            time.sleep(0.3)
+    return False
+
+
+def open_tab(port: int, url: str) -> Dict[str, Any]:
+    """Abre una pestaña en la URL y devuelve su target info."""
+    target = http_json(port, f"/json/new?{url}", method="PUT")
+    if "webSocketDebuggerUrl" not in target:
+        raise CdpError("el navegador no devolvio websocket para la pestaña")
+    return target
+
+
+class Tab:
+    """Una pestaña conectada por WebSocket, con eval sincrono."""
+
+    def __init__(self, target: Dict[str, Any]):
+        parsed = urlparse(target["webSocketDebuggerUrl"])
+        self.ws = WebSocket(parsed.hostname, parsed.port or 80, parsed.path)
+        self._id = 0
+        self._counter_events: int = 0
+
+    def send(self, method: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        self._id += 1
+        mid = self._id
+        self.ws.send_text(json.dumps({"id": mid, "method": method, "params": params or {}}))
+        while True:
+            msg = json.loads(self.ws.recv_text())
+            if msg.get("id") == mid:
+                if "error" in msg:
+                    raise CdpError(f"{method}: {msg['error'].get('message')}")
+                return msg.get("result", {})
+            # eventos: se descartan (Page.enable etc. no son necesarios aqui)
+
+    def eval(self, expression: str) -> Any:
+        res = self.send("Runtime.evaluate", {
+            "expression": expression,
+            "returnByValue": True,
+            "awaitPromise": True,
+        })
+        if res.get("exceptionDetails"):
+            detail = res["exceptionDetails"].get("exception", {}).get("description", "")
+            raise CdpError(f"JS fallo: {detail[:200]}")
+        return res.get("result", {}).get("value")
+
+    def close(self) -> None:
+        self.ws.close()

ghlike-0.1.0/src/ghlike/cli.py

@@ -0,0 +1,99 @@
+"""CLI de ghlike: da (o quita) el like de un repo de GitHub con tu sesion del navegador.
+
+    ghlike owner/repo          # dar star (si ya lo tienes, lo dice y no hace nada)
+    ghlike owner/repo -u       # quitar el star
+    ghlike owner/repo -c       # solo consultar
+    ghlike owner/repo --toggle # invertir
+    ghlike --list              # sesiones de GitHub detectadas en los navegadores
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from . import __version__
+from .browsers import find_sessions
+from .core import GhlikeError, NoSessionError, RepoNotFoundError, run
+
+EXIT_OK, EXIT_ERROR, EXIT_NO_SESSION, EXIT_NOT_FOUND = 0, 1, 2, 3
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="ghlike",
+        description="Like (star) en repos de GitHub usando la sesion ya iniciada en tu navegador. "
+                    "Sin tokens: se abre tu navegador en modo invisible y pulsa el boton por ti.")
+    p.add_argument("repo", nargs="?", help="repo en formato 'owner/repo' o URL de GitHub")
+    p.add_argument("-u", "--unstar", action="store_true", help="quitar el star en vez de darlo")
+    p.add_argument("-c", "--check", action="store_true", help="solo consultar el estado actual")
+    p.add_argument("--toggle", action="store_true", help="invertir el estado actual")
+    p.add_argument("--browser", metavar="NOMBRE", help="forzar un navegador (brave, chrome, chromium, edge, vivaldi, opera)")
+    p.add_argument("--json", action="store_true", dest="as_json", help="salida en JSON")
+    p.add_argument("--list", action="store_true", help="listar sesiones de GitHub detectadas y salir")
+    p.add_argument("--version", action="version", version=f"ghlike {__version__}")
+    return p
+
+
+def _print_sessions(as_json: bool) -> int:
+    sessions = find_sessions()
+    if as_json:
+        print(json.dumps([{"browser": s.browser.label, "exe": s.exe,
+                           "profile": s.profile_name, "github_cookies": s.cookie_count}
+                          for s in sessions], indent=2))
+        return EXIT_OK
+    if not sessions:
+        print("No se ha encontrado ninguna sesion de github.com en los navegadores Chromium.")
+        return EXIT_NO_SESSION
+    print("Sesiones de github.com detectadas:")
+    for s in sessions:
+        print(f"  - {s.browser.label}: perfil {s.profile_name} ({s.cookie_count} cookies de sesion)")
+        print(f"      {s.exe}")
+    return EXIT_OK
+
+
+def main(argv=None) -> int:
+    args = _build_parser().parse_args(argv)
+
+    if args.list:
+        return _print_sessions(args.as_json)
+    if not args.repo:
+        _build_parser().print_usage(sys.stderr)
+        print("ghlike: falta el repo (p. ej. 'ghlike cli/cli')", file=sys.stderr)
+        return EXIT_ERROR
+    if sum([args.unstar, args.check, args.toggle]) > 1:
+        print("ghlike: --unstar, --check y --toggle son mutuamente excluyentes", file=sys.stderr)
+        return EXIT_ERROR
+
+    action = "unstar" if args.unstar else "check" if args.check else "toggle" if args.toggle else "star"
+    try:
+        r = run(args.repo, action=action, browser=args.browser)
+    except NoSessionError as e:
+        print(f"ghlike: {e}", file=sys.stderr)
+        return EXIT_NO_SESSION
+    except RepoNotFoundError as e:
+        print(f"ghlike: {e}", file=sys.stderr)
+        return EXIT_NOT_FOUND
+    except GhlikeError as e:
+        print(f"ghlike: {e}", file=sys.stderr)
+        return EXIT_ERROR
+
+    if args.as_json:
+        print(json.dumps(r))
+        return EXIT_OK
+
+    who = f"[{r['user']} via {r['browser']}]"
+    if r["action"] == "check":
+        state = "con like" if r["after"] else "sin like"
+        print(f"{r['repo']}: {state} {who}")
+    elif not r["changed"]:
+        state = "ya tenia like" if r["after"] else "ya estaba sin like"
+        print(f"{r['repo']}: {state}, sin cambios {who}")
+    else:
+        verb = "like dado :star:" if r["after"] else "like quitado"
+        print(f"{r['repo']}: {verb} {who}")
+    return EXIT_OK
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ghlike-0.1.0/src/ghlike/core.py

@@ -0,0 +1,245 @@
+"""Orquestación: sesion del navegador -> Brave/Chrome headless con CDP -> click en Star.
+
+El "like" se hace clicando el boton real de github.com con la propia sesion
+del usuario, igual que lo haria a mano. Sin tokens, sin API, sin credenciales
+en claro: las cookies cifradas se copian a un perfil temporal local que solo
+el navegador puede abrir, y todo se borra al terminar.
+"""
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import signal
+import socket
+import subprocess
+import time
+from typing import Any, Dict, Optional
+
+from .browsers import BROWSERS, copy_session, find_sessions
+from .cdp import Tab, open_tab, wait_for_cdp
+
+REPO_RE = re.compile(r"^([\w.\-]+)/([\w.\-]+)$")
+URL_RE = re.compile(r"github\.com/([\w.\-]+)/([\w.\-]+)")
+
+# Lectura del estado del boton star. GitHub renderiza el repo con React: no
+# hay formularios clasicos ni authenticity_token en el HTML; el click dispara
+# internamente el POST correcto con su propio CSRF.
+STATE_JS = """(() => {
+  const btn = document.querySelector(
+    'button[aria-label^="Star"], button[aria-label^="Unstar"], button[aria-label^="Starred"]');
+  const meta = document.querySelector('meta[name="user-login"]');
+  return {
+    login: meta ? meta.content : null,
+    found: !!btn,
+    starred: btn ? ((btn.getAttribute('aria-label') || '').startsWith('Unstar')
+                    || /Starred/i.test(btn.innerText || '')) : null,
+    aria: btn ? btn.getAttribute('aria-label') : null,
+    notFound: /Page not found|404 "not found"/i.test(document.title)
+  };
+})()"""
+
+CLICK_JS = """(() => {
+  const btn = document.querySelector(
+    'button[aria-label^="Star"], button[aria-label^="Unstar"], button[aria-label^="Starred"]');
+  if (!btn) return false;
+  btn.click();
+  return true;
+})()"""
+
+
+class GhlikeError(RuntimeError):
+    pass
+
+
+class NoSessionError(GhlikeError):
+    pass
+
+
+class RepoNotFoundError(GhlikeError):
+    pass
+
+
+def star(repo: str, browser: Optional[str] = None) -> Dict[str, Any]:
+    return run(repo, action="star", browser=browser)
+
+
+def unstar(repo: str, browser: Optional[str] = None) -> Dict[str, Any]:
+    return run(repo, action="unstar", browser=browser)
+
+
+def toggle(repo: str, browser: Optional[str] = None) -> Dict[str, Any]:
+    return run(repo, action="toggle", browser=browser)
+
+
+def check(repo: str, browser: Optional[str] = None) -> Dict[str, Any]:
+    return run(repo, action="check", browser=browser)
+
+
+def parse_repo(text: str) -> str:
+    text = text.strip().rstrip("/")
+    m = URL_RE.search(text)
+    if m:
+        return f"{m.group(1)}/{m.group(2)}"
+    if text.startswith("https://") or text.startswith("http://"):
+        raise GhlikeError(f"URL no reconocida como repo de GitHub: {text}")
+    if REPO_RE.match(text):
+        return text
+    raise GhlikeError(f"formato esperado 'owner/repo' o URL de GitHub: {text}")
+
+
+def _free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+def _kill_tree(proc: subprocess.Popen) -> None:
+    """Mata el grupo de procesos completo del navegador (snap incluido).
+
+    Matar solo el Popen no basta: /snap/bin/brave es un wrapper y el binario
+    real queda huérfano (y sigue escribiendo en el perfil temporal).
+    """
+    try:
+        pgid = os.getpgid(proc.pid)
+    except ProcessLookupError:
+        proc.terminate()
+        return
+    for sig in (signal.SIGTERM, signal.SIGKILL):
+        try:
+            os.killpg(pgid, sig)
+        except ProcessLookupError:
+            return
+        for _ in range(50):  # hasta 5s por señal
+            try:
+                os.killpg(pgid, 0)
+            except ProcessLookupError:
+                return
+            time.sleep(0.1)
+
+
+def _rmtree_retry(path: str, attempts: int = 4) -> None:
+    for _ in range(attempts):
+        shutil.rmtree(path, ignore_errors=True)
+        if not os.path.exists(path):
+            return
+        time.sleep(0.5)
+
+
+def _wait_ready(tab: Tab, timeout: float = 25.0) -> None:
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        try:
+            if tab.eval("document.readyState") == "complete":
+                return
+        except Exception:
+            pass
+        time.sleep(0.4)
+    raise GhlikeError("la pagina no termino de cargar")
+
+
+def _read_state(tab: Tab) -> Dict[str, Any]:
+    deadline = time.monotonic() + 10.0
+    while time.monotonic() < deadline:
+        try:
+            st = tab.eval(STATE_JS)
+            if st and st.get("login") is not None:
+                return st
+        except Exception:
+            pass
+        time.sleep(0.5)
+    return tab.eval(STATE_JS) or {}
+
+
+def run(repo: str, action: str = "star", browser: Optional[str] = None,
+        timeout: float = 60.0) -> Dict[str, Any]:
+    """Ejecuta la accion ('star' | 'unstar' | 'toggle' | 'check') contra un repo.
+
+    Devuelve un dict con repo, before/after, navegador usado y usuario.
+    """
+    if action not in ("star", "unstar", "toggle", "check"):
+        raise GhlikeError(f"accion desconocida: {action}")
+    repo = parse_repo(repo)
+
+    sessions = find_sessions(browser)
+    if not sessions:
+        if browser and browser.lower() not in {b.name for b in BROWSERS}:
+            known = ", ".join(b.name for b in BROWSERS)
+            raise NoSessionError(
+                f"navegador '{browser}' no soportado (soportados: {known}). "
+                "Firefox no funciona: no implementa CDP.")
+        raise NoSessionError(
+            "no se encontro ninguna sesion de github.com en los perfiles de "
+            "Brave/Chrome/Chromium/Edge/Vivaldi/Opera. Logueate en el navegador primero.")
+
+    last_session_failure = None
+    for session in sessions:
+        tmp = copy_session(session)
+        port = _free_port()
+        cmd = [
+            session.exe,
+            "--headless=new", "--disable-gpu", "--no-first-run",
+            "--no-default-browser-check", "--disable-component-update",
+            f"--user-data-dir={tmp}",
+            f"--profile-directory={session.profile_name}",
+            f"--remote-debugging-port={port}",
+            "about:blank",
+        ]
+        proc = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                                start_new_session=True)
+        try:
+            if proc.poll() is not None or not wait_for_cdp(port):
+                raise GhlikeError(f"{session.browser.label} no arranco con el puerto de depuracion")
+            target = open_tab(port, f"https://github.com/{repo}")
+            tab = Tab(target)
+            try:
+                _wait_ready(tab)
+                time.sleep(2.0)  # margen para la hidratacion de React
+                st = _read_state(tab)
+
+                if st.get("notFound"):
+                    raise RepoNotFoundError(f"el repo {repo} no existe (o no es visible)")
+                if not st.get("login"):
+                    last_session_failure = (
+                        f"la sesion de {session.browser.label} ({session.profile_name}) "
+                        "no se pudo usar: ¿sigues logueado en github.com?")
+                    continue  # probar el siguiente perfil/navegador
+                if not st.get("found"):
+                    raise GhlikeError(
+                        "no se encontro el boton de star: el markup de GitHub cambio, "
+                        "abre un issue en el repo del proyecto")
+
+                before = bool(st["starred"])
+                result: Dict[str, Any] = {
+                    "repo": repo, "user": st["login"],
+                    "browser": session.browser.label, "profile": session.profile_name,
+                    "before": before,
+                }
+                if action == "check":
+                    result.update(action="check", after=before, changed=False)
+                    return result
+
+                desired = not before if action == "toggle" else (action == "star")
+                result["action"] = action
+                if before != desired:
+                    if not tab.eval(CLICK_JS):
+                        raise GhlikeError("el boton de star desaparecio antes del click")
+                    flipped = False
+                    deadline = time.monotonic() + 15.0
+                    while time.monotonic() < deadline:
+                        time.sleep(0.6)
+                        st2 = _read_state(tab)
+                        if bool(st2.get("starred")) == desired:
+                            flipped = True
+                            break
+                    if not flipped:
+                        raise GhlikeError("el click no cambio el estado del star (rate limit o cambio de UI)")
+                result["after"] = desired if before != desired else before
+                result["changed"] = result["after"] != result["before"]
+                return result
+            finally:
+                tab.close()
+        finally:
+            _kill_tree(proc)
+            _rmtree_retry(tmp)
+    raise NoSessionError(last_session_failure or "ninguna sesion de navegador pudo usarse")

ghlike-0.1.0/src/ghlike/ws.py

@@ -0,0 +1,90 @@
+"""Cliente WebSocket mínimo (RFC 6455) sobre stdlib, para hablar CDP en localhost.
+
+Alcance deliberadamente reducido: handshake cliente, frames de texto en ambas
+direcciones y enmascaramiento de salida. Es todo lo que el DevTools protocol
+de un navegador local necesita, y evita cualquier dependencia externa.
+"""
+from __future__ import annotations
+
+import base64
+import os
+import socket
+import struct
+
+
+class WebSocket:
+    def __init__(self, host: str, port: int, path: str, timeout: float = 30.0):
+        self.sock = socket.create_connection((host, int(port)), timeout=timeout)
+        key = base64.b64encode(os.urandom(16)).decode()
+        request = (
+            f"GET {path} HTTP/1.1\r\n"
+            f"Host: {host}:{port}\r\n"
+            "Upgrade: websocket\r\n"
+            "Connection: Upgrade\r\n"
+            f"Sec-WebSocket-Key: {key}\r\n"
+            "Sec-WebSocket-Version: 13\r\n"
+            "User-Agent: ghlike\r\n"
+            "\r\n"
+        )
+        self.sock.sendall(request.encode())
+        buf = b""
+        while b"\r\n\r\n" not in buf:
+            chunk = self.sock.recv(4096)
+            if not chunk:
+                raise IOError("conexion cerrada durante el handshake")
+            buf += chunk
+        head, _, rest = buf.partition(b"\r\n\r\n")
+        status = head.split(b"\r\n", 1)[0]
+        if b"101" not in status:
+            raise IOError(f"handshake rechazado: {status!r}")
+        self._buf = rest
+
+    def _read(self, n: int) -> bytes:
+        while len(self._buf) < n:
+            chunk = self.sock.recv(4096)
+            if not chunk:
+                raise IOError("conexion cerrada")
+            self._buf += chunk
+        out, self._buf = self._buf[:n], self._buf[n:]
+        return out
+
+    def send_text(self, text: str) -> None:
+        payload = text.encode()
+        mask = os.urandom(4)
+        header = bytearray([0x81])  # FIN + text frame
+        n = len(payload)
+        if n < 126:
+            header.append(0x80 | n)
+        elif n < 65536:
+            header.append(0x80 | 126)
+            header += struct.pack(">H", n)
+        else:
+            header.append(0x80 | 127)
+            header += struct.pack(">Q", n)
+        header += mask
+        masked = bytes(b ^ mask[i % 4] for i, b in enumerate(payload))
+        self.sock.sendall(bytes(header) + masked)
+
+    def recv_text(self) -> str:
+        while True:
+            b1, b2 = self._read(2)
+            opcode = b1 & 0x0F
+            n = b2 & 0x7F
+            if n == 126:
+                n = struct.unpack(">H", self._read(2))[0]
+            elif n == 127:
+                n = struct.unpack(">Q", self._read(8))[0]
+            if opcode & 0x80:  # MASK nunca llega del servidor CDP; defiende igual
+                self._read(4)
+            payload = self._read(n)
+            if opcode == 0x1:
+                return payload.decode("utf-8", "replace")
+            if opcode == 0x8:
+                raise IOError("conexion cerrada por el peer")
+            # ping (0x9) / pong (0xA) / continuacion: ignorar
+
+    def close(self) -> None:
+        try:
+            self.sock.close()
+        except OSError:
+            pass

ghlike-0.1.0/src/ghlike.egg-info/PKG-INFO

@@ -0,0 +1,195 @@
+Metadata-Version: 2.4
+Name: ghlike
+Version: 0.1.0
+Summary: Like (star) repos on GitHub with your existing browser session — no tokens, no API keys.
+Author: ghlike contributors
+License: MIT
+Project-URL: Homepage, https://github.com/686f6c61/ghlike-py
+Project-URL: Repository, https://github.com/686f6c61/ghlike-py
+Project-URL: Issues, https://github.com/686f6c61/ghlike-py/issues
+Project-URL: Changelog, https://github.com/686f6c61/ghlike-py/releases
+Keywords: github,star,like,cli,browser-session
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ghlike
+
+**Star GitHub repos with your browser session — no tokens. / Da estrellas
+en GitHub con la sesión de tu navegador — sin tokens.**
+
+[English](#english) · [Español](#español)
+
+This is the Python CLI of the [ghlike project](https://github.com/686f6c61/ghlike)
+(like-button widget + browser extension + Node CLI live there). Zero
+dependencies: the CDP WebSocket client is implemented on the standard
+library, so the whole package audits in one sitting.
+
+---
+
+# English
+
+## What it does
+
+`ghlike owner/repo` stars a GitHub repository using the login session
+already active in your browser. No `gh auth login`, no personal access
+tokens, no OAuth: if you're logged into GitHub in Brave, Chrome, Chromium,
+Edge, Vivaldi or Opera (native or snap installs), it just works.
+
+How: it finds the browser profile with your github.com session → copies the
+**encrypted** cookie store to a throwaway profile → opens your own browser
+headless with a private debug port → clicks the real Star button (GitHub
+handles its own CSRF) → verifies → kills the browser and deletes the
+profile. Cookies are never decrypted and never leave your machine.
+
+## Install
+
+```bash
+pipx install ghlike        # or: pip install --user ghlike
+```
+
+Requires Python ≥ 3.9 and a Chromium-family browser with a github.com
+session. Firefox is not supported (no CDP).
+
+## CLI
+
+```bash
+ghlike owner/repo            # star (idempotent — tells you if already starred)
+ghlike https://github.com/o/r  # full URLs work
+ghlike owner/repo -c         # check current state only
+ghlike owner/repo -u         # unstar
+ghlike owner/repo --toggle   # flip
+ghlike --list                # github.com sessions found in your browsers
+ghlike --browser brave o/r   # force one browser (strict)
+ghlike o/r --json            # machine-readable output
+```
+
+Exit codes: `0` ok (incl. nothing-to-do) · `1` generic error · `2` no
+github.com session · `3` repo not found.
+
+JSON example:
+
+```bash
+$ ghlike cli/cli --check --json
+{"repo":"cli/cli","user":"you","browser":"Brave","profile":"Default",
+ "before":false,"action":"check","after":false,"changed":false}
+```
+
+## Library
+
+```python
+from ghlike import star, unstar, check, toggle
+
+star("vercel/next.js")                 # -> {"repo": ..., "changed": True, ...}
+state = check("vercel/next.js")        # -> {"repo": ..., "after": True/False, ...}
+unstar("vercel/next.js", browser="brave")
+toggle("vercel/next.js")
+```
+
+Exceptions: `NoSessionError`, `RepoNotFoundError`, `GhlikeError`.
+
+## Limitations
+
+- Chromium-family browsers only; Firefox is not supported (no CDP).
+- Each operation takes ~8–12 s (headless browser + page load). That's the
+  price of the no-token approach.
+- Depends on GitHub's Star button; if the markup changes, one selector line
+  fixes it (`STATE_JS` in `src/ghlike/core.py`).
+
+## Development
+
+```bash
+PYTHONPATH=src python3 -m ghlike.cli --list
+python -m pip wheel . --no-deps --no-build-isolation -w dist
+```
+
+Publishing is automated: push a git tag / create a GitHub Release `vX.Y.Z`
+and `.github/workflows/publish-pypi.yml` publishes to PyPI via
+[Trusted Publishing](https://docs.pypi.org/trusted-publishers/) (no
+secrets). Versions live in `pyproject.toml` and `src/ghlike/__init__.py`.
+
+License: MIT.
+
+---
+
+# Español
+
+## Qué hace
+
+`ghlike owner/repo` da una estrella a un repositorio de GitHub usando la
+sesión ya iniciada en tu navegador. Sin `gh auth login`, sin personal access
+tokens, sin OAuth: si estás logueado en GitHub en Brave, Chrome, Chromium,
+Edge, Vivaldi u Opera (nativo o snap), funciona directamente.
+
+Cómo: busca el perfil del navegador con tu sesión de github.com → copia la
+tienda de cookies **cifrada** a un perfil desechable → abre tu propio
+navegador en modo invisible con un puerto de depuración privado → pulsa el
+botón de Star real (GitHub gestiona su propio CSRF) → verifica → cierra el
+navegador y borra el perfil. Las cookies nunca se descifran ni salen de tu
+máquina.
+
+## Instalación
+
+```bash
+pipx install ghlike        # o: pip install --user ghlike
+```
+
+Requiere Python ≥ 3.9 y un navegador de la familia Chromium con sesión de
+github.com. Firefox no está soportado (sin CDP).
+
+## CLI
+
+```bash
+ghlike owner/repo            # dar star (idempotente)
+ghlike https://github.com/o/r  # URLs completas valen
+ghlike owner/repo -c         # solo consultar estado
+ghlike owner/repo -u         # quitar star
+ghlike owner/repo --toggle   # invertir
+ghlike --list                # sesiones de GitHub detectadas
+ghlike --browser brave o/r   # forzar un navegador (estricto)
+ghlike o/r --json            # salida para scripts
+```
+
+Códigos de salida: `0` ok (también "nada que hacer") · `1` error genérico ·
+`2` sin sesión de github.com · `3` repo no encontrado.
+
+## Librería
+
+```python
+from ghlike import star, unstar, check, toggle
+
+star("vercel/next.js")                 # -> {"repo": ..., "changed": True, ...}
+state = check("vercel/next.js")        # -> {"repo": ..., "after": True/False, ...}
+unstar("vercel/next.js", browser="brave")
+```
+
+Excepciones: `NoSessionError`, `RepoNotFoundError`, `GhlikeError`.
+
+## Limitaciones
+
+- Solo navegadores Chromium; Firefox no (sin CDP).
+- Cada operación tarda ~8–12 s (navegador invisible + carga). Es el precio
+  del enfoque sin tokens.
+- Depende del botón de Star de GitHub; si cambia el markup, se arregla con
+  una línea (`STATE_JS` en `src/ghlike/core.py`).
+
+## Desarrollo
+
+```bash
+PYTHONPATH=src python3 -m ghlike.cli --list
+python -m pip wheel . --no-deps --no-build-isolation -w dist
+```
+
+La publicación es automática: crea un Release `vX.Y.Z` en GitHub y
+`.github/workflows/publish-pypi.yml` publica en PyPI con Trusted Publishing
+(sin secrets). Las versiones viven en `pyproject.toml` y
+`src/ghlike/__init__.py`.
+
+Licencia: MIT.

ghlike-0.1.0/src/ghlike.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/ghlike/__init__.py
+src/ghlike/browsers.py
+src/ghlike/cdp.py
+src/ghlike/cli.py
+src/ghlike/core.py
+src/ghlike/ws.py
+src/ghlike.egg-info/PKG-INFO
+src/ghlike.egg-info/SOURCES.txt
+src/ghlike.egg-info/dependency_links.txt
+src/ghlike.egg-info/entry_points.txt
+src/ghlike.egg-info/top_level.txt

ghlike-0.1.0/src/ghlike.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ghlike-0.1.0/src/ghlike.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ghlike = ghlike.cli:main

ghlike-0.1.0/src/ghlike.egg-info/top_level.txt

@@ -0,0 +1 @@
+ghlike