pairling 0.0.1 → 0.1.0

package/payload/mac/install/render-launchd.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""Render Pairling launchd plists with absolute runtime paths."""
+
+from __future__ import annotations
+
+import argparse
+import plistlib
+from pathlib import Path
+
+PAIRLING_DAEMON_LABEL = "dev.pairling.companiond"
+PAIRLING_GUARDIAN_LABEL = "dev.pairling.power-guardian"
+PAIRLING_CONNECTD_LABEL = "dev.pairling.connectd"
+PAIRLING_RUNTIME_PORT = "7773"
+
+
+def write_plist(path: Path, payload: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("wb") as fh:
+        plistlib.dump(payload, fh, sort_keys=False)
+
+
+def daemon_plist(current: Path, logs: Path, python_bin: str) -> dict:
+    return {
+        "Label": PAIRLING_DAEMON_LABEL,
+        "ProgramArguments": [
+            python_bin,
+            str(current / "companiond" / "pairlingd.py"),
+        ],
+        "EnvironmentVariables": {
+            "PAIRLING_RUNTIME_PORT": PAIRLING_RUNTIME_PORT,
+            "COMPANION_DAEMON_PORT": PAIRLING_RUNTIME_PORT,
+            "PAIRLING_BIND_MODE": "all",
+            "PAIRLING_APP_SUPPORT_ROOT": str(current.parent.parent),
+            "PAIRLING_LOGS_ROOT": str(logs),
+            "PATH": "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin",
+        },
+        "RunAtLoad": True,
+        "KeepAlive": True,
+        "ThrottleInterval": 10,
+        "StandardOutPath": str(logs / "companiond.log"),
+        "StandardErrorPath": str(logs / "companiond.err"),
+    }
+
+
+def guardian_plist(current: Path, logs: Path, python_bin: str) -> dict:
+    return {
+        "Label": PAIRLING_GUARDIAN_LABEL,
+        "ProgramArguments": [
+            python_bin,
+            str(current / "guardian" / "companion-power-guardian.py"),
+        ],
+        "EnvironmentVariables": {
+            "PAIRLING_RUNTIME_PORT": PAIRLING_RUNTIME_PORT,
+            "COMPANION_DAEMON_PORT": PAIRLING_RUNTIME_PORT,
+            "COMPANION_COORDINATOR_HOST": "pairling-mac",
+            "COMPANION_GUARDIAN_ENFORCE": "0",
+            "COMPANION_LOW_POWER_MODE_POLICY": "preserve",
+            "COMPANION_POWER_INTERVAL_SECONDS": "20",
+            "COMPANION_POWER_STATE_PATH": "/var/run/pairling-power-state.json",
+            "PATH": "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin",
+        },
+        "RunAtLoad": True,
+        "KeepAlive": True,
+        "StandardOutPath": str(logs / "power-guardian.log"),
+        "StandardErrorPath": str(logs / "power-guardian.err"),
+    }
+
+
+def connectd_plist(current: Path, logs: Path) -> dict:
+    app_support = current.parent.parent
+    return {
+        "Label": PAIRLING_CONNECTD_LABEL,
+        "ProgramArguments": [
+            str(current / "connectd" / "pairling-connectd"),
+            "--upstream",
+            f"http://127.0.0.1:{PAIRLING_RUNTIME_PORT}",
+            "--listen",
+            f":{PAIRLING_RUNTIME_PORT}",
+            "--status-addr",
+            "127.0.0.1:7774",
+            "--state-dir",
+            str(app_support / "connectd" / "tsnet-state"),
+        ],
+        "EnvironmentVariables": {
+            "PAIRLING_RUNTIME_PORT": PAIRLING_RUNTIME_PORT,
+            "PAIRLING_APP_SUPPORT_ROOT": str(app_support),
+            "PAIRLING_LOGS_ROOT": str(logs),
+            "PATH": "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin",
+        },
+        "RunAtLoad": True,
+        "KeepAlive": True,
+        "ThrottleInterval": 10,
+        "StandardOutPath": str(logs / "connectd.log"),
+        "StandardErrorPath": str(logs / "connectd.err"),
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--current-root", required=True)
+    parser.add_argument("--logs-root", required=True)
+    parser.add_argument("--output-dir", required=True)
+    parser.add_argument("--daemon-python", default="/usr/local/bin/python3")
+    parser.add_argument("--guardian-python", default="/usr/bin/python3")
+    parser.add_argument("--mirror-python", default="/usr/local/bin/python3", help=argparse.SUPPRESS)
+    args = parser.parse_args()
+
+    current = Path(args.current_root)
+    logs = Path(args.logs_root)
+    out = Path(args.output_dir)
+
+    write_plist(out / f"{PAIRLING_DAEMON_LABEL}.plist", daemon_plist(current, logs, args.daemon_python))
+    write_plist(out / f"{PAIRLING_GUARDIAN_LABEL}.plist", guardian_plist(current, logs, args.guardian_python))
+    write_plist(out / f"{PAIRLING_CONNECTD_LABEL}.plist", connectd_plist(current, logs))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/payload/mac/install/uninstall-runtime.sh

@@ -0,0 +1,136 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+PAIRLING_DAEMON_LABEL="dev.pairling.companiond"
+PAIRLING_GUARDIAN_LABEL="dev.pairling.power-guardian"
+PAIRLING_CONNECTD_LABEL="dev.pairling.connectd"
+LEGACY_DAEMON_LABEL="com.mghome.notify-webhook"
+APP_SUPPORT="${PAIRLING_APP_SUPPORT_ROOT:-${COMPANION_APP_SUPPORT_ROOT:-$HOME/Library/Application Support/Pairling}}"
+LOGS_ROOT="${PAIRLING_LOGS_ROOT:-${COMPANION_LOGS_ROOT:-$HOME/Library/Logs/Pairling}}"
+USER_PLIST="$HOME/Library/LaunchAgents/$PAIRLING_DAEMON_LABEL.plist"
+CONNECTD_USER_PLIST="$HOME/Library/LaunchAgents/$PAIRLING_CONNECTD_LABEL.plist"
+LEGACY_USER_PLIST="$HOME/Library/LaunchAgents/$LEGACY_DAEMON_LABEL.plist"
+SYSTEM_PLIST="/Library/LaunchDaemons/$PAIRLING_GUARDIAN_LABEL.plist"
+LEGACY_SYSTEM_PLIST="/Library/LaunchDaemons/com.mghome.companion-power-guardian.plist"
+YES="false"
+DELETE_STATE="false"
+DELETE_LOGS="false"
+DRY_RUN="${PAIRLING_DRY_RUN:-0}"
+
+usage() {
+  cat <<EOF
+usage: pairling uninstall [--yes] [--delete-state] [--delete-logs]
+
+Default behavior stops Pairling and removes Pairling launchd plists while
+preserving devices, state, logs, provider transcripts, and user projects.
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --yes|-y)
+      YES="true"
+      ;;
+    --delete-state|--remove-runtime)
+      DELETE_STATE="true"
+      ;;
+    --delete-logs)
+      DELETE_LOGS="true"
+      ;;
+    --help|-h)
+      usage
+      exit 0
+      ;;
+    *)
+      usage >&2
+      exit 2
+      ;;
+  esac
+  shift
+done
+
+is_dry_run() {
+  [[ "$DRY_RUN" == "1" || "$DRY_RUN" == "true" || "$DRY_RUN" == "TRUE" ]]
+}
+
+confirm() {
+  if [[ "$YES" == "true" ]]; then
+    return
+  fi
+  printf 'This will stop Pairling and remove its LaunchAgent.\n'
+  printf 'Preserve state: %s\n' "$APP_SUPPORT"
+  printf 'Preserve logs:  %s\n' "$LOGS_ROOT"
+  printf 'Type "uninstall Pairling" to continue: '
+  local answer
+  IFS= read -r answer
+  if [[ "$answer" != "uninstall Pairling" ]]; then
+    printf 'Cancelled.\n' >&2
+    exit 1
+  fi
+}
+
+bootout_user() {
+  local label="$1"
+  local plist="$2"
+  if is_dry_run; then
+    printf 'dry-run: would unload %s\n' "$label"
+    return
+  fi
+  launchctl bootout "gui/$(id -u)/$label" >/dev/null 2>&1 || true
+  launchctl bootout "gui/$(id -u)" "$plist" >/dev/null 2>&1 || true
+}
+
+bootout_system() {
+  local label="$1"
+  local plist="$2"
+  if [[ ! -f "$plist" ]]; then
+    return
+  fi
+  if is_dry_run; then
+    printf 'dry-run: would unload system/%s\n' "$label"
+    return
+  fi
+  if sudo -n true >/dev/null 2>&1; then
+    sudo launchctl bootout "system/$label" >/dev/null 2>&1 || true
+    sudo launchctl bootout system "$plist" >/dev/null 2>&1 || true
+    sudo rm -f "$plist"
+  else
+    printf 'Skipping %s removal: passwordless sudo is unavailable.\n' "$plist" >&2
+  fi
+}
+
+confirm
+
+bootout_user "$PAIRLING_DAEMON_LABEL" "$USER_PLIST"
+bootout_user "$PAIRLING_CONNECTD_LABEL" "$CONNECTD_USER_PLIST"
+rm -f "$USER_PLIST"
+rm -f "$CONNECTD_USER_PLIST"
+bootout_system "$PAIRLING_GUARDIAN_LABEL" "$SYSTEM_PLIST"
+
+if [[ -f "$LEGACY_USER_PLIST" ]]; then
+  bootout_user "$LEGACY_DAEMON_LABEL" "$LEGACY_USER_PLIST"
+  printf 'Warning: legacy LaunchAgent still exists and was unloaded if possible: %s\n' "$LEGACY_USER_PLIST"
+fi
+
+if [[ -f "$LEGACY_SYSTEM_PLIST" ]]; then
+  printf 'Warning: legacy guardian LaunchDaemon still exists: %s\n' "$LEGACY_SYSTEM_PLIST"
+fi
+
+rm -rf "$APP_SUPPORT/pair" 2>/dev/null || true
+
+if [[ "$DELETE_STATE" == "true" ]]; then
+  rm -rf "$APP_SUPPORT"
+  printf 'Deleted Pairling state: %s\n' "$APP_SUPPORT"
+else
+  printf 'Preserved Pairling state and devices: %s\n' "$APP_SUPPORT"
+fi
+
+if [[ "$DELETE_LOGS" == "true" ]]; then
+  rm -rf "$LOGS_ROOT"
+  printf 'Deleted Pairling logs: %s\n' "$LOGS_ROOT"
+else
+  printf 'Preserved Pairling logs: %s\n' "$LOGS_ROOT"
+fi
+
+printf 'Provider transcripts and user projects were not removed.\n'
+printf 'Reinstall with: pairling setup\n'

package/payload/mac/mcp/phone_tools.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+"""Pairling daemon-first MCP bridge for phone-tools."""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import http.client
+import json
+import os
+import sys
+import time
+from urllib.parse import urlparse
+import uuid
+from pathlib import Path
+from typing import Any
+
+try:
+    from mcp.server.fastmcp import FastMCP
+except Exception as exc:  # pragma: no cover - exercised only in a broken MCP env
+    print(f"FATAL: cannot import FastMCP: {exc}", file=sys.stderr)
+    raise
+
+
+PAIRLING_TOOLS_BASE_URL = os.environ.get("PAIRLING_TOOLS_BASE_URL", "http://127.0.0.1:7773").rstrip("/")
+PAIRLING_TOOLS_TIMEOUT = float(os.environ.get("PAIRLING_TOOLS_TIMEOUT", "15"))
+PAIRLING_MCP_CREDENTIAL = Path(
+    os.environ.get(
+        "PAIRLING_MCP_CREDENTIAL",
+        str(Path.home() / "Library" / "Application Support" / "Pairling" / "mcp-bridge.json"),
+    )
+)
+
+INSTALL_ID_HEADER = "Pairling-Install-ID"
+REQUEST_ID_HEADER = "Pairling-Request-ID"
+TIMESTAMP_HEADER = "Pairling-Timestamp"
+BODY_SHA256_HEADER = "Pairling-Body-SHA256"
+PROOF_HEADER = "Pairling-Proof"
+
+
+class PairlingToolsClient:
+    def __init__(
+        self,
+        *,
+        base_url: str = PAIRLING_TOOLS_BASE_URL,
+        credential_path: Path = PAIRLING_MCP_CREDENTIAL,
+        timeout: float = PAIRLING_TOOLS_TIMEOUT,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.credential_path = credential_path
+        self.timeout = timeout
+
+    def run(self, tool: str, input_payload: dict[str, Any], *, strategy: str = "auto") -> str:
+        if os.environ.get("PAIRLING_TOOLS_DIRECT_IPHONE") == "1":
+            return _direct_iphone_diagnostic(tool, input_payload)
+        body = json.dumps({
+            "tool": tool,
+            "input": input_payload,
+            "strategy": strategy,
+        }, separators=(",", ":")).encode("utf-8")
+        credential = self._load_credential()
+        url = self.base_url + "/pairling-tools/run"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": "Bearer " + credential["token"],
+            **_proof_headers(
+                credential=credential,
+                method="POST",
+                path_and_query="/pairling-tools/run",
+                body=body,
+            ),
+        }
+        try:
+            status, reason, payload = self._post_json(url, body, headers)
+        except Exception as exc:
+            return f"[phone-tools] Pairling tools unavailable: cannot reach Pairling daemon at {self.base_url}: {type(exc).__name__}: {exc}"
+        if not isinstance(payload, dict):
+            return f"[phone-tools] Pairling tools unavailable: HTTP {status}: {reason}"
+
+        if payload.get("ok"):
+            return str(payload.get("result") or "")
+        error = payload.get("error") if isinstance(payload.get("error"), dict) else {}
+        message = error.get("message") or error.get("code") or "unknown error"
+        iphone_reason = error.get("iphone_reason")
+        mac_reason = error.get("mac_reason")
+        detail = ""
+        if iphone_reason or mac_reason:
+            detail = f" iPhone={iphone_reason or 'not_attempted'} Mac={mac_reason or 'not_attempted'}."
+        return f"[phone-tools] Pairling tools unavailable: {message}.{detail}"
+
+    def _post_json(self, url: str, body: bytes, headers: dict[str, str]) -> tuple[int, str, dict[str, Any] | None]:
+        parsed = urlparse(url)
+        if parsed.scheme != "http" or parsed.hostname not in {"127.0.0.1", "localhost", "::1"}:
+            raise RuntimeError("Pairling MCP adapter only connects to the local Pairling daemon")
+        port = parsed.port or 80
+        path = parsed.path or "/"
+        if parsed.query:
+            path += "?" + parsed.query
+        conn = http.client.HTTPConnection(parsed.hostname, port, timeout=self.timeout)
+        try:
+            conn.request("POST", path, body=body, headers=headers)
+            response = conn.getresponse()
+            raw = response.read()
+        finally:
+            conn.close()
+        try:
+            payload = json.loads(raw.decode("utf-8"))
+        except Exception:
+            payload = None
+        return response.status, response.reason, payload
+
+    def _load_credential(self) -> dict[str, str]:
+        try:
+            payload = json.loads(self.credential_path.read_text())
+        except Exception as exc:
+            raise RuntimeError(
+                f"Pairling MCP bridge credential is missing. Run `pairling setup` or `pairling doctor --json`: {exc}"
+            ) from exc
+        required = ("device_id", "install_id", "token", "proof_secret")
+        missing = [key for key in required if not str(payload.get(key) or "").strip()]
+        if missing:
+            raise RuntimeError("Pairling MCP bridge credential is incomplete: " + ", ".join(missing))
+        return {key: str(payload[key]) for key in required}
+
+
+def _proof_headers(*, credential: dict[str, str], method: str, path_and_query: str, body: bytes) -> dict[str, str]:
+    timestamp_ms = str(int(time.time() * 1000))
+    request_id = str(uuid.uuid4()).lower()
+    body_hash = hashlib.sha256(body).hexdigest()
+    canonical = "\n".join([
+        method.upper(),
+        path_and_query,
+        timestamp_ms,
+        request_id,
+        body_hash,
+        credential["install_id"],
+        credential["device_id"],
+    ])
+    proof = hmac.new(
+        credential["proof_secret"].encode("utf-8"),
+        canonical.encode("utf-8"),
+        hashlib.sha256,
+    ).hexdigest()
+    return {
+        INSTALL_ID_HEADER: credential["install_id"],
+        REQUEST_ID_HEADER: request_id,
+        TIMESTAMP_HEADER: timestamp_ms,
+        BODY_SHA256_HEADER: body_hash,
+        PROOF_HEADER: proof,
+    }
+
+
+def _direct_iphone_diagnostic(tool: str, input_payload: dict[str, Any]) -> str:
+    socket = __import__("socket")
+    host = os.environ.get("PHONE_TS_HOST", "iphone-15-pro")
+    port = int(os.environ.get("PHONE_TS_PORT", "7724"))
+    timeout = float(os.environ.get("PHONE_TIMEOUT", "5"))
+    token = os.environ.get("PHONE_TOKEN")
+    if not token:
+        token_file = Path.home() / ".claude" / "scripts" / ".notify-token"
+        try:
+            token = token_file.read_text().strip()
+        except OSError as exc:
+            return f"[phone-tools] Direct iPhone diagnostic unavailable: token missing: {exc}"
+    request = json.dumps({"tool": tool, "token": token, "input": input_payload}) + "\n"
+    try:
+        with socket.create_connection((host, port), timeout=timeout) as sock:
+            sock.sendall(request.encode("utf-8"))
+            line = sock.recv(65536).split(b"\n", 1)[0]
+    except Exception as exc:
+        return f"[phone-tools] Direct iPhone diagnostic failed at {host}:{port}: {exc}"
+    try:
+        payload = json.loads(line.decode("utf-8"))
+    except Exception as exc:
+        return f"[phone-tools] Direct iPhone diagnostic bad response: {exc}"
+    if not payload.get("ok"):
+        return f"[phone-tools] Direct iPhone diagnostic tool failed: {payload.get('error', 'unknown error')}"
+    return str(payload.get("result") or "")
+
+
+CLIENT = PairlingToolsClient()
+mcp = FastMCP("phone-tools")
+
+
+@mcp.tool()
+def second_opinion(claim: str) -> str:
+    """Get a skeptical second opinion on a claim."""
+    return CLIENT.run("second_opinion", {"claim": claim})
+
+
+@mcp.tool()
+def vibe_check(draft: str) -> str:
+    """Check whether a piece of writing matches the user's typical voice."""
+    return CLIENT.run("vibe_check", {"draft": draft})
+
+
+@mcp.tool()
+def user_likely_prefers(option_a: str, option_b: str) -> str:
+    """Predict which of two options the user is likely to prefer."""
+    return CLIENT.run("user_likely_prefers", {"option_a": option_a, "option_b": option_b})
+
+
+@mcp.tool()
+def corpus_recall(query: str) -> str:
+    """Search the user's past Pairling-accessible local session corpus."""
+    return CLIENT.run("corpus_recall", {"query": query})
+
+
+if __name__ == "__main__":
+    mcp.run()

package/payload/mac/packaging/bin/pairling

@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ -n "${PAIRLING_REPO_ROOT:-}" ]]; then
+  REPO_ROOT="$PAIRLING_REPO_ROOT"
+else
+  SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+  REPO_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+fi
+
+export PYTHONDONTWRITEBYTECODE=1
+if [[ -z "${PYTHONPYCACHEPREFIX:-}" ]]; then
+  PYTHONPYCACHEPREFIX="${TMPDIR:-/tmp}/pairling-pycache-$(id -u)"
+  mkdir -p "$PYTHONPYCACHEPREFIX" 2>/dev/null || true
+  export PYTHONPYCACHEPREFIX
+fi
+
+if [[ "${1:-}" == "attach" ]]; then
+  shift
+  exec python3 "$REPO_ROOT/mac/packaging/pairling_attach.py" "$@"
+fi
+
+if [[ "${1:-}" == "connect-auth-open" ]]; then
+  shift || true
+  json_mode="false"
+  while [[ $# -gt 0 ]]; do
+    case "$1" in
+      --json)
+        json_mode="true"
+        shift
+        ;;
+      --help|-h)
+        printf 'usage: pairling connect-auth-open [--json]\n'
+        exit 0
+        ;;
+      *)
+        printf 'usage: pairling connect-auth-open [--json]\n' >&2
+        exit 2
+        ;;
+    esac
+  done
+  if output="$(/usr/bin/curl -sS --max-time 5 -X POST http://127.0.0.1:7774/auth/open 2>/dev/null)"; then
+    if python3 -c 'import json,sys; sys.exit(0 if json.load(sys.stdin).get("ok") else 1)' <<<"$output"; then
+      response_status=0
+    else
+      response_status=1
+    fi
+    if [[ "$json_mode" == "true" ]]; then
+      printf '%s\n' "$output"
+    else
+      python3 -c 'import json,sys; data=json.load(sys.stdin); print("Pairling Connect browser approval opened." if data.get("opened") else data.get("error", "Pairling Connect browser approval is not available."))' <<<"$output"
+    fi
+    exit "$response_status"
+  fi
+  if [[ "$json_mode" == "true" ]]; then
+    printf '{"ok":false,"opened":false,"auth_url_present":false,"error":"Pairling Connect auth endpoint unavailable."}\n'
+  else
+    printf 'Pairling Connect auth endpoint unavailable.\n' >&2
+  fi
+  exit 1
+fi
+
+exec "$REPO_ROOT/mac/install/install-runtime.sh" "$@"