hiair-cli 0.1.0__py3-none-any.whl

hiair_cli/__init__.py

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

hiair_cli/__main__.py

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

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/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/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/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)

hiair_cli/main.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import socket
+import time
+
+from hiair_cli import __version__
+from hiair_cli.auth import (
+    clear_credentials,
+    default_api_url,
+    load_credentials,
+    require_token,
+    save_credentials,
+)
+from hiair_cli.chrome import cdp_ready
+from hiair_cli.client import CliApiError, CliClient
+from hiair_cli.daemon import run_daemon
+from hiair_cli.service import describe as service_describe
+from hiair_cli.service import install as service_install
+from hiair_cli.service import uninstall as service_uninstall
+
+
+def _device_name() -> str:
+    return socket.gethostname() or "My computer"
+
+
+def cmd_login(args: argparse.Namespace) -> None:
+    api_url = (args.api_url or default_api_url()).rstrip("/")
+    client = CliClient(api_url=api_url)
+    try:
+        pairing = client.pair_start(_device_name())
+    except CliApiError as exc:
+        raise SystemExit(f"Could not start pairing: {exc.detail}") from exc
+    user_code = pairing["user_code"]
+    verify = pairing["verification_url"]
+    print(f"Open {verify}")
+    print(f"Enter this code: {user_code}")
+    print("Waiting for confirmation…")
+    started = time.monotonic()
+    while time.monotonic() - started < 600:
+        try:
+            result = client.pair_token(pairing["device_code"])
+        except CliApiError as exc:
+            if exc.status_code == 202:
+                time.sleep(2)
+                continue
+            if exc.status_code == 410:
+                raise SystemExit("That pairing code expired. Run `hiair login` again.") from exc
+            raise SystemExit(f"Pairing failed: {exc.detail}") from exc
+        if result.get("pending") or result.get("status") == "pending":
+            time.sleep(2)
+            continue
+        token = result.get("token")
+        if not token:
+            time.sleep(2)
+            continue
+        save_credentials(
+            token=token,
+            api_url=api_url,
+            device_id=str(result.get("device_id") or ""),
+            device_name=str(result.get("device_name") or _device_name()),
+        )
+        print("Paired. Run `hiair service install` to fill applications at login.")
+        return
+    raise SystemExit("Timed out waiting for confirmation.")
+
+
+def cmd_logout(_args: argparse.Namespace) -> None:
+    data = load_credentials()
+    token = str(data.get("token") or "")
+    api_url = str(data.get("api_url") or default_api_url())
+    if token:
+        try:
+            CliClient(api_url=api_url, token=token).logout()
+        except Exception:
+            pass
+    clear_credentials()
+    print("Logged out.")
+
+
+def cmd_status(_args: argparse.Namespace) -> None:
+    token, api_url = require_token()
+    client = CliClient(api_url=api_url, token=token)
+    try:
+        me = client.me()
+    except CliApiError as exc:
+        raise SystemExit(f"Status failed: {exc.detail}") from exc
+    print(f"API:     {api_url}")
+    print(f"Device:  {me.get('device_name') or '—'}")
+    print(f"Online:  {'yes' if me.get('online') else 'no (run `hiair service install`)'}")
+    print(f"Service: {service_describe()}")
+    print(f"Chrome:  {'debug port open' if cdp_ready() else 'idle'}")
+
+
+def cmd_service_install(_args: argparse.Namespace) -> None:
+    require_token()
+    service_install()
+
+
+def cmd_service_uninstall(_args: argparse.Namespace) -> None:
+    service_uninstall()
+
+
+def cmd_service_status(_args: argparse.Namespace) -> None:
+    data = load_credentials()
+    if not str(data.get("token") or "").strip():
+        print(f"Service: {service_describe()}")
+        print("Pairing: not logged in")
+        return
+    cmd_status(_args)
+
+
+def cmd_apply(args: argparse.Namespace) -> None:
+    token, api_url = require_token()
+    if args.api_url:
+        api_url = args.api_url.rstrip("/")
+    client = CliClient(api_url=api_url, token=token)
+    print(f"Listening for applies at {api_url}")
+    print("Queue jobs from the HiAir site. Chrome opens when a job arrives.")
+    try:
+        asyncio.run(run_daemon(client))
+    except KeyboardInterrupt:
+        print("\nStopped.")
+
+
+def _add_api_url(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--api-url",
+        default=None,
+        help="Jobs API base URL (default: $HIAIR_API_URL or https://api.hiair.ai)",
+    )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="hiair", description="Apply to jobs from your Chrome")
+    parser.add_argument(
+        "-V",
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    login = sub.add_parser("login", help="Pair this computer with your HiAir account")
+    _add_api_url(login)
+    login.set_defaults(func=cmd_login)
+
+    logout = sub.add_parser("logout", help="Forget the saved CLI token")
+    logout.set_defaults(func=cmd_logout)
+
+    status = sub.add_parser("status", help="Show pairing and Chrome status")
+    status.set_defaults(func=cmd_status)
+
+    apply_cmd = sub.add_parser("apply", help="Claim queued applies and fill them in Chrome")
+    _add_api_url(apply_cmd)
+    apply_cmd.set_defaults(func=cmd_apply)
+
+    service = sub.add_parser("service", help="Install a login worker (macOS)")
+    service_sub = service.add_subparsers(dest="service_command", required=True)
+
+    service_install_cmd = service_sub.add_parser(
+        "install", help="Start the apply worker at login"
+    )
+    service_install_cmd.set_defaults(func=cmd_service_install)
+
+    service_uninstall_cmd = service_sub.add_parser(
+        "uninstall", help="Stop and remove the login worker"
+    )
+    service_uninstall_cmd.set_defaults(func=cmd_service_uninstall)
+
+    service_status_cmd = service_sub.add_parser(
+        "status", help="Show whether the login worker is loaded"
+    )
+    service_status_cmd.set_defaults(func=cmd_service_status)
+
+    args = parser.parse_args()
+    args.func(args)
+
+
+if __name__ == "__main__":
+    main()

hiair_cli/mcp.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+from contextlib import AsyncExitStack
+
+MCP_PACKAGE = "@playwright/mcp@0.0.79"
+
+
+def _mcp_text(result: Any) -> str:
+    parts: list[str] = []
+    for item in getattr(result, "content", None) or []:
+        kind = getattr(item, "type", None)
+        if kind == "text":
+            text = getattr(item, "text", None)
+            if text:
+                parts.append(str(text))
+        elif kind == "image":
+            parts.append("[image]")
+    text = "\n".join(parts).strip()
+    if getattr(result, "isError", False):
+        return f"error: {text or 'tool failed'}"
+    return text or "ok"
+
+
+def _mcp_image_bytes(result: Any) -> bytes | None:
+    import base64
+
+    for item in getattr(result, "content", None) or []:
+        if getattr(item, "type", None) != "image":
+            continue
+        data = getattr(item, "data", None)
+        if not data:
+            continue
+        try:
+            return base64.b64decode(data)
+        except Exception:
+            return None
+    return None
+
+
+class LocalPlaywrightMcp:
+    def __init__(self, *, output_dir: Path, cdp_endpoint: str) -> None:
+        self.output_dir = Path(output_dir)
+        self.cdp_endpoint = cdp_endpoint
+        self._stack: AsyncExitStack | None = None
+        self._session: Any = None
+        self._specs: list[dict[str, Any]] = []
+
+    def tool_specs(self) -> list[dict[str, Any]]:
+        return self._specs
+
+    async def start(self) -> None:
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        params = StdioServerParameters(
+            command="npx",
+            args=[
+                "-y",
+                MCP_PACKAGE,
+                "--allow-unrestricted-file-access",
+                "--output-dir",
+                str(self.output_dir),
+                "--cdp-endpoint",
+                self.cdp_endpoint,
+            ],
+            cwd=str(self.output_dir),
+            env=dict(os.environ),
+        )
+        stack = AsyncExitStack()
+        try:
+            read, write = await stack.enter_async_context(stdio_client(params))
+            session = await stack.enter_async_context(ClientSession(read, write))
+            await session.initialize()
+            listed = await session.list_tools()
+        except Exception:
+            await stack.aclose()
+            raise
+        self._stack = stack
+        self._session = session
+        self._specs = [
+            {
+                "name": getattr(tool, "name", None),
+                "description": getattr(tool, "description", None),
+                "inputSchema": (
+                    getattr(tool, "input_schema", None)
+                    or getattr(tool, "inputSchema", None)
+                ),
+            }
+            for tool in (listed.tools or [])
+            if getattr(tool, "name", None)
+        ]
+
+    async def close(self) -> None:
+        stack = self._stack
+        self._stack = None
+        self._session = None
+        if stack is not None:
+            try:
+                await stack.aclose()
+            except Exception:
+                pass
+
+    async def call(self, name: str, arguments: dict[str, Any]) -> str:
+        if self._session is None:
+            raise RuntimeError("Playwright MCP is not started")
+        try:
+            result = await self._session.call_tool(name, arguments or {})
+        except Exception as exc:
+            return f"error: {exc}"
+        return _mcp_text(result)
+
+    async def screenshot(self, *, full_page: bool = True) -> bytes | None:
+        if self._session is None:
+            return None
+        result = await self._session.call_tool(
+            "browser_take_screenshot", {"fullPage": full_page}
+        )
+        return _mcp_image_bytes(result)

hiair_cli/service.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import os
+import platform
+import plistlib
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from hiair_cli.auth import CONFIG_DIR
+
+LABEL = "ai.hiair.apply"
+PLIST_PATH = Path.home() / "Library/LaunchAgents" / f"{LABEL}.plist"
+LOG_PATH = CONFIG_DIR / "logs" / "apply.log"
+_LAUNCHD_PATH = (
+    "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"
+)
+
+
+def _require_macos() -> None:
+    if platform.system() != "Darwin":
+        raise SystemExit(
+            "hiair service is only supported on macOS. Run `hiair apply` in the foreground."
+        )
+
+
+def _gui_target() -> str:
+    return f"gui/{os.getuid()}"
+
+
+def _service_target() -> str:
+    return f"{_gui_target()}/{LABEL}"
+
+
+def _hiair_executable() -> Path:
+    raw = Path(sys.argv[0]).expanduser()
+    if raw.exists() and raw.is_file():
+        return raw.resolve()
+    found = shutil.which("hiair")
+    if found:
+        return Path(found)
+    raise SystemExit(
+        "Could not find the hiair executable. Install with `pipx install hiair-cli`."
+    )
+
+
+def _launchctl(*args: str) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(["launchctl", *args], capture_output=True, text=True)
+
+
+def is_loaded() -> bool:
+    return _launchctl("print", _service_target()).returncode == 0
+
+
+def _write_plist(exe: Path) -> None:
+    PLIST_PATH.parent.mkdir(parents=True, exist_ok=True)
+    LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "Label": LABEL,
+        "ProgramArguments": [str(exe), "apply"],
+        "RunAtLoad": True,
+        "KeepAlive": True,
+        "LimitLoadToSessionType": "Aqua",
+        "StandardOutPath": str(LOG_PATH),
+        "StandardErrorPath": str(LOG_PATH),
+        "EnvironmentVariables": {
+            "PATH": _LAUNCHD_PATH,
+            "HOME": str(Path.home()),
+        },
+    }
+    PLIST_PATH.write_bytes(plistlib.dumps(payload))
+
+
+def install() -> None:
+    _require_macos()
+    exe = _hiair_executable()
+    _write_plist(exe)
+    if is_loaded():
+        _launchctl("bootout", _service_target())
+    result = _launchctl("bootstrap", _gui_target(), str(PLIST_PATH))
+    if result.returncode != 0:
+        detail = (result.stderr or result.stdout or "").strip()
+        raise SystemExit(f"Could not load the HiAir login worker: {detail or 'launchctl failed'}")
+    _launchctl("kickstart", "-k", _service_target())
+    print(f"Installed login worker ({exe} apply).")
+    print("It starts at login and opens Chrome only when a job is queued.")
+    print(f"Logs: {LOG_PATH}")
+
+
+def uninstall() -> None:
+    _require_macos()
+    if is_loaded():
+        result = _launchctl("bootout", _service_target())
+        if result.returncode != 0:
+            detail = (result.stderr or result.stdout or "").strip()
+            raise SystemExit(f"Could not stop the HiAir login worker: {detail or 'launchctl failed'}")
+    if PLIST_PATH.is_file():
+        PLIST_PATH.unlink()
+    print("Removed the HiAir login worker.")
+
+
+def describe() -> str:
+    if platform.system() != "Darwin":
+        return "not supported (macOS only)"
+    if is_loaded():
+        return "loaded"
+    if PLIST_PATH.is_file():
+        return "installed but not loaded"
+    return "not installed"

hiair_cli-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,14 @@
+hiair_cli/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+hiair_cli/__main__.py,sha256=q7ysFUPkiS6DqZV6MBXcuilDqJm0s8lkpIlPFmc-CaI,71
+hiair_cli/auth.py,sha256=6dFQAJ5diMb06TD9rRDY96aj3GBrtVr0UExOZBI_uPg,1452
+hiair_cli/chrome.py,sha256=QGLDJFwnia_8r8GB5DR4aw55tKHTjlLrmpcScsg_F-o,4130
+hiair_cli/client.py,sha256=A7skNs1K-jWmEm4C_pTJj2px5TVbcQJ9SYGaY7dATrY,3853
+hiair_cli/daemon.py,sha256=JzUVl_8zrAoa9CjLAdZcrLcfzugf2WOp9spUjxp4EKY,4748
+hiair_cli/main.py,sha256=Yovspk4TT3GX1XdQSxSMWEn8qZJMWlQ7_KYtOQtLqCg,5967
+hiair_cli/mcp.py,sha256=3Bem06VBPlgge6qiukcJNLt4tdyVSLLggW63LAHZvxw,3878
+hiair_cli/service.py,sha256=L2VLee8c9e3XyIcJFQ0b_ps_Jd7AXW-iFOqGAqAGOgU,3238
+hiair_cli-0.1.0.dist-info/METADATA,sha256=uUkug-UdTtYbZii4zdigxTyGwh35hsRKqy7beojRUPg,1786
+hiair_cli-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+hiair_cli-0.1.0.dist-info/entry_points.txt,sha256=ILDPC4v3MBqzC6ecyBNLB8HtmWMpOKFxAv8kk52mD34,46
+hiair_cli-0.1.0.dist-info/licenses/LICENSE,sha256=y05rLv3VU7r8vCmFxdTCr3yfHZJA1zoAZfYDkAjE-U8,1062
+hiair_cli-0.1.0.dist-info/RECORD,,

hiair_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

hiair_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+hiair = hiair_cli.main:main

hiair_cli-0.1.0.dist-info/licenses/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.