hiair-cli 0.1.0__tar.gz

hiair_cli-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,50 @@
+name: Publish
+
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v6
+
+      - name: Build sdist and wheel
+        run: uv build
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/hiair-cli
+    permissions:
+      id-token: write
+      contents: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist
+
+      - uses: pypa/gh-action-pypi-publish@release/v1
+
+      - name: GitHub Release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release create "${{ github.ref_name }}" dist/* \
+            --title "${{ github.ref_name }}" \
+            --generate-notes \
+            --verify-tag

hiair_cli-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+.venv/
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/

hiair_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 HiAir
+
+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.

hiair_cli-0.1.0/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.5
+Name: hiair-cli
+Version: 0.1.0
+Summary: Run HiAir applies in your own Chrome
+Project-URL: Homepage, https://hiair.ai
+Project-URL: Repository, https://github.com/hiair-ai/hiair-cli
+Project-URL: Issues, https://github.com/hiair-ai/hiair-cli/issues
+Author-email: HiAir <admin@hiair.ai>
+License: MIT
+License-File: LICENSE
+Keywords: apply,chrome,hiair,jobs
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: mcp>=2.0.0
+Description-Content-Type: text/markdown
+
+# HiAir CLI
+
+Fill job applications in **your** Chrome, then store them in the HiAir tracker.
+
+## Install
+
+You need [Python 3.11+](https://www.python.org/downloads/) and [pipx](https://pipx.pypa.io/). Google Chrome must be installed for applies.
+
+```bash
+pipx install hiair-cli
+# or: uv tool install hiair-cli
+
+hiair login
+hiair service install
+```
+
+After that, the worker starts at login. Queue jobs from the website or copilot; when one arrives, this Mac opens a disposable Chrome, fills the application, and writes the result back. Everyday Chrome can stay open. Logins in the HiAir window do not persist.
+
+`hiair service` is macOS only. To watch a run in the foreground (any OS), use `hiair apply`.
+
+```bash
+hiair --version
+hiair status
+hiair service status
+hiair service uninstall
+```

hiair_cli-0.1.0/README.md

@@ -0,0 +1,26 @@
+# HiAir CLI
+
+Fill job applications in **your** Chrome, then store them in the HiAir tracker.
+
+## Install
+
+You need [Python 3.11+](https://www.python.org/downloads/) and [pipx](https://pipx.pypa.io/). Google Chrome must be installed for applies.
+
+```bash
+pipx install hiair-cli
+# or: uv tool install hiair-cli
+
+hiair login
+hiair service install
+```
+
+After that, the worker starts at login. Queue jobs from the website or copilot; when one arrives, this Mac opens a disposable Chrome, fills the application, and writes the result back. Everyday Chrome can stay open. Logins in the HiAir window do not persist.
+
+`hiair service` is macOS only. To watch a run in the foreground (any OS), use `hiair apply`.
+
+```bash
+hiair --version
+hiair status
+hiair service status
+hiair service uninstall
+```

hiair_cli-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[project]
+name = "hiair-cli"
+dynamic = ["version"]
+description = "Run HiAir applies in your own Chrome"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "HiAir", email = "admin@hiair.ai" }]
+keywords = ["hiair", "jobs", "apply", "chrome"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: End Users/Desktop",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Office/Business",
+]
+dependencies = [
+    "httpx>=0.27.0",
+    "mcp>=2.0.0",
+]
+
+[project.urls]
+Homepage = "https://hiair.ai"
+Repository = "https://github.com/hiair-ai/hiair-cli"
+Issues = "https://github.com/hiair-ai/hiair-cli/issues"
+
+[project.scripts]
+hiair = "hiair_cli.main:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+path = "src/hiair_cli/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/hiair_cli"]

hiair_cli-0.1.0/src/hiair_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

hiair_cli-0.1.0/src/hiair_cli/__main__.py

@@ -0,0 +1,4 @@
+from hiair_cli.main import main
+
+if __name__ == "__main__":
+    main()

hiair_cli-0.1.0/src/hiair_cli/auth.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+CONFIG_DIR = Path.home() / ".hiair"
+CREDENTIALS_PATH = CONFIG_DIR / "credentials"
+
+
+def default_api_url() -> str:
+    return (os.environ.get("HIAIR_API_URL") or "https://api.hiair.ai").rstrip("/")
+
+
+def load_credentials() -> dict[str, Any]:
+    if not CREDENTIALS_PATH.is_file():
+        return {}
+    try:
+        data = json.loads(CREDENTIALS_PATH.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def save_credentials(*, token: str, api_url: str, device_id: str, device_name: str) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "token": token,
+        "api_url": api_url.rstrip("/"),
+        "device_id": device_id,
+        "device_name": device_name,
+    }
+    CREDENTIALS_PATH.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
+    try:
+        CREDENTIALS_PATH.chmod(0o600)
+    except OSError:
+        pass
+
+
+def clear_credentials() -> None:
+    if CREDENTIALS_PATH.is_file():
+        CREDENTIALS_PATH.unlink()
+
+
+def require_token() -> tuple[str, str]:
+    data = load_credentials()
+    token = str(data.get("token") or "").strip()
+    api_url = str(data.get("api_url") or default_api_url()).rstrip("/")
+    if not token:
+        raise SystemExit("Not logged in. Run `hiair login` first.")
+    return token, api_url

hiair_cli-0.1.0/src/hiair_cli/chrome.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import signal
+import socket
+import subprocess
+import tempfile
+import time
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from pathlib import Path
+
+DEFAULT_CDP_PORT = 9222
+CDP_URL = f"http://127.0.0.1:{DEFAULT_CDP_PORT}"
+
+
+@dataclass
+class ChromeSession:
+    endpoint: str
+    process: subprocess.Popen[bytes]
+    profile_dir: str
+
+
+def cdp_ready(url: str = f"{CDP_URL}/json/version") -> bool:
+    try:
+        with urllib.request.urlopen(url, timeout=1.5) as response:
+            return 200 <= response.status < 300
+    except (urllib.error.URLError, TimeoutError, OSError):
+        return False
+
+
+def find_chrome() -> Path:
+    system = platform.system()
+    candidates: list[Path] = []
+    if system == "Darwin":
+        candidates.append(Path("/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"))
+    elif system == "Windows":
+        for env in ("PROGRAMFILES", "PROGRAMFILES(X86)", "LOCALAPPDATA"):
+            root = os.environ.get(env)
+            if root:
+                candidates.append(Path(root) / "Google/Chrome/Application/chrome.exe")
+    else:
+        for name in ("google-chrome", "google-chrome-stable", "chromium", "chromium-browser"):
+            found = shutil.which(name)
+            if found:
+                return Path(found)
+    for path in candidates:
+        if path.is_file():
+            return path
+    raise SystemExit(
+        "Google Chrome was not found. Install Chrome and try `hiair apply` again."
+    )
+
+
+def _port_open(port: int) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.settimeout(0.3)
+        return sock.connect_ex(("127.0.0.1", port)) == 0
+
+
+def _wait_for_cdp(endpoint: str, *, seconds: float = 20) -> bool:
+    deadline = time.monotonic() + seconds
+    while time.monotonic() < deadline:
+        if cdp_ready(f"{endpoint}/json/version"):
+            return True
+        time.sleep(0.25)
+    return False
+
+
+def _pick_cdp_port(preferred: int) -> int:
+    if not _port_open(preferred):
+        return preferred
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.bind(("127.0.0.1", 0))
+        return int(sock.getsockname()[1])
+
+
+def ensure_chrome(*, cdp_port: int = DEFAULT_CDP_PORT) -> ChromeSession:
+    """Launch a fresh Chrome that exposes CDP.
+
+    Chrome 136+ ignores --remote-debugging-port on the default profile, so each
+    run gets a unique temp user-data-dir. Everyday Chrome can stay open.
+    """
+
+    port = _pick_cdp_port(cdp_port)
+    endpoint = f"http://127.0.0.1:{port}"
+    profile_dir = tempfile.mkdtemp(prefix="hiair-chrome-")
+    chrome = find_chrome()
+    args = [
+        str(chrome),
+        f"--remote-debugging-port={port}",
+        "--remote-allow-origins=*",
+        f"--user-data-dir={profile_dir}",
+        "--no-first-run",
+        "--no-default-browser-check",
+    ]
+    print("Opening a fresh Chrome. Your everyday Chrome can stay open.")
+    process = subprocess.Popen(
+        args,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        start_new_session=True,
+    )
+    session = ChromeSession(endpoint=endpoint, process=process, profile_dir=profile_dir)
+    if _wait_for_cdp(endpoint):
+        print(f"Chrome is ready on {endpoint}")
+        return session
+    close_chrome(session)
+    raise RuntimeError(
+        "Chrome started but remote debugging did not come up. "
+        "Quit leftover HiAir Chrome windows and try again."
+    )
+
+
+def close_chrome(session: ChromeSession) -> None:
+    proc = session.process
+    if proc.poll() is not None:
+        return
+    try:
+        os.killpg(proc.pid, signal.SIGTERM)
+    except (ProcessLookupError, PermissionError, OSError):
+        proc.terminate()
+    try:
+        proc.wait(timeout=5)
+    except subprocess.TimeoutExpired:
+        try:
+            os.killpg(proc.pid, signal.SIGKILL)
+        except (ProcessLookupError, PermissionError, OSError):
+            proc.kill()
+        try:
+            proc.wait(timeout=3)
+        except subprocess.TimeoutExpired:
+            pass

hiair_cli-0.1.0/src/hiair_cli/client.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from hiair_cli.auth import default_api_url
+
+
+class CliApiError(RuntimeError):
+    def __init__(self, status_code: int, detail: str) -> None:
+        super().__init__(detail)
+        self.status_code = status_code
+        self.detail = detail
+
+
+class CliClient:
+    def __init__(self, *, api_url: str | None = None, token: str | None = None) -> None:
+        self.api_url = (api_url or default_api_url()).rstrip("/")
+        self.token = token
+        self._http = httpx.Client(timeout=60.0)
+
+    def close(self) -> None:
+        self._http.close()
+
+    def _headers(self, *, auth: bool = False) -> dict[str, str]:
+        headers = {"Accept": "application/json"}
+        if auth:
+            if not self.token:
+                raise SystemExit("Not logged in. Run `hiair login` first.")
+            headers["Authorization"] = f"Bearer {self.token}"
+        return headers
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        auth: bool = False,
+        json: Any = None,
+        params: dict[str, Any] | None = None,
+        timeout: float | None = None,
+        accept_empty: bool = False,
+    ) -> Any:
+        response = self._http.request(
+            method,
+            f"{self.api_url}{path}",
+            headers=self._headers(auth=auth),
+            json=json,
+            params=params,
+            timeout=timeout,
+        )
+        if response.status_code == 202:
+            return {"pending": True}
+        if accept_empty and response.status_code in {200, 204} and not response.content:
+            return None
+        if response.status_code >= 400:
+            detail = response.text
+            try:
+                payload = response.json()
+                raw = payload.get("detail")
+                if isinstance(raw, str):
+                    detail = raw
+                elif isinstance(raw, dict):
+                    detail = str(raw.get("message") or raw)
+            except Exception:
+                pass
+            raise CliApiError(response.status_code, detail)
+        if not response.content:
+            return None
+        return response.json()
+
+    def pair_start(self, name: str) -> dict[str, Any]:
+        return self._request("POST", "/cli/pair/start", json={"name": name})
+
+    def pair_token(self, device_code: str) -> dict[str, Any]:
+        return self._request("POST", "/cli/pair/token", json={"device_code": device_code})
+
+    def me(self) -> dict[str, Any]:
+        return self._request("GET", "/cli/me", auth=True)
+
+    def heartbeat(self) -> dict[str, Any]:
+        return self._request("POST", "/cli/heartbeat", auth=True)
+
+    def logout(self) -> None:
+        self._request("POST", "/cli/logout", auth=True, accept_empty=True)
+
+    def next_run(self, *, wait: float = 25) -> dict[str, Any] | None:
+        return self._request(
+            "GET",
+            "/cli/runs/next",
+            auth=True,
+            params={"wait": wait},
+            timeout=wait + 10,
+            accept_empty=True,
+        )
+
+    def turn(
+        self,
+        run_id: int,
+        *,
+        tools: list[dict[str, Any]] | None = None,
+        resume_path: str | None = None,
+        results: list[dict[str, Any]] | None = None,
+    ) -> dict[str, Any]:
+        return self._request(
+            "POST",
+            f"/cli/runs/{run_id}/turn",
+            auth=True,
+            json={
+                "tools": tools or [],
+                "resume_path": resume_path,
+                "results": results or [],
+            },
+            timeout=180,
+        )
+
+    def upload_artifacts(self, run_id: int, items: list[dict[str, Any]]) -> dict[str, Any]:
+        return self._request(
+            "POST",
+            f"/cli/runs/{run_id}/artifacts",
+            auth=True,
+            json=items,
+        )

hiair_cli-0.1.0/src/hiair_cli/daemon.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import asyncio
+import base64
+import tempfile
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+from hiair_cli.chrome import close_chrome, ensure_chrome
+from hiair_cli.client import CliApiError, CliClient
+from hiair_cli.mcp import LocalPlaywrightMcp
+
+CAPTURE_AFTER = frozenset(
+    {
+        "browser_click",
+        "browser_click_element",
+        "browser_type",
+        "browser_press_key",
+        "browser_select_option",
+        "browser_fill_form",
+        "browser_navigate",
+    }
+)
+HEARTBEAT_SECONDS = 20
+
+
+async def _download_resume(url: str, dest: Path) -> None:
+    async with httpx.AsyncClient(follow_redirects=True, timeout=60) as client:
+        response = await client.get(url)
+        response.raise_for_status()
+        dest.write_bytes(response.content)
+
+
+def _artifact(filename: str, data: bytes, kind: str) -> dict[str, Any]:
+    return {
+        "filename": filename,
+        "content_base64": base64.b64encode(data).decode("ascii"),
+        "kind": kind,
+    }
+
+
+async def _run_one(client: CliClient, claim: dict[str, Any], mcp: LocalPlaywrightMcp) -> None:
+    run_id = int(claim["run_id"])
+    resume_name = str(claim.get("resume_file_name") or "resume.pdf")
+    resume_path = mcp.output_dir / resume_name
+    resume_url = (claim.get("resume_url") or "").strip()
+    if resume_url:
+        try:
+            await _download_resume(resume_url, resume_path)
+        except Exception as exc:
+            print(f"  could not download resume: {exc}")
+    print(f"Applying to {claim.get('job_title') or claim.get('job_url')} (run {run_id})")
+    results: list[dict[str, Any]] = []
+    tools = mcp.tool_specs()
+    first = True
+    frames: list[dict[str, Any]] = []
+    seq = 0
+    while True:
+        turn = client.turn(
+            run_id,
+            tools=tools if first else None,
+            resume_path=str(resume_path) if first else None,
+            results=results,
+        )
+        first = False
+        if turn.get("finished"):
+            status = turn.get("status") or "unknown"
+            print(f"  finished: {status}")
+            if turn.get("error"):
+                print(f"  {turn['error']}")
+            try:
+                proof = await mcp.screenshot(full_page=True)
+                items = list(frames)
+                if proof:
+                    items.append(_artifact("filled.png", proof, "proof"))
+                if items:
+                    client.upload_artifacts(run_id, items)
+            except Exception as exc:
+                print(f"  could not upload proof: {exc}")
+            return
+        results = []
+        for call in turn.get("tool_calls") or []:
+            name = str(call.get("name") or "")
+            args = call.get("args") or {}
+            print(f"  → {name}")
+            output = await mcp.call(name, args)
+            results.append({"id": str(call.get("id") or ""), "output": output})
+            if name in CAPTURE_AFTER:
+                seq += 1
+                try:
+                    png = await mcp.screenshot(full_page=True)
+                    if png:
+                        frames.append(_artifact(f"{seq:04d}-{name}.png", png, "screenshot"))
+                except Exception:
+                    pass
+
+
+async def run_daemon(client: CliClient) -> None:
+    heartbeat = asyncio.create_task(_heartbeat_loop(client))
+    try:
+        while True:
+            try:
+                claim = client.next_run(wait=25)
+            except CliApiError as exc:
+                print(f"API error: {exc.detail}")
+                await asyncio.sleep(5)
+                continue
+            if not claim:
+                continue
+            chrome = None
+            mcp = None
+            try:
+                chrome = ensure_chrome()
+                output_dir = Path(tempfile.mkdtemp(prefix=f"hiair-apply-{claim['run_id']}-"))
+                mcp = LocalPlaywrightMcp(output_dir=output_dir, cdp_endpoint=chrome.endpoint)
+                await mcp.start()
+                await _run_one(client, claim, mcp)
+            except CliApiError as exc:
+                print(f"  apply failed: {exc.detail}")
+            except Exception as exc:
+                print(f"  apply crashed: {exc}")
+            finally:
+                if mcp is not None:
+                    await mcp.close()
+                if chrome is not None:
+                    close_chrome(chrome)
+    finally:
+        heartbeat.cancel()
+        try:
+            await heartbeat
+        except (asyncio.CancelledError, Exception):
+            pass
+
+
+async def _heartbeat_loop(client: CliClient) -> None:
+    while True:
+        try:
+            client.heartbeat()
+        except Exception:
+            pass
+        await asyncio.sleep(HEARTBEAT_SECONDS)