pairling 0.2.11 → 0.2.12

package/payload/mac/companiond/runtime_contract.py

@@ -6,7 +6,6 @@ from __future__ import annotations
 import os
 
 SCHEMA_VERSION = 1
-POWER_STATE_SCHEMA_VERSION = 1
 RUNTIME_NAME = "pairling-mac-runtime"
 CONTRACT_VERSION = "pairling-runtime-v1"
 PAIRLING_CONTRACT_VERSION = CONTRACT_VERSION
@@ -14,9 +13,7 @@ COMPAT_MODE = "pairling-v1"
 PORT = int(os.environ.get("PAIRLING_RUNTIME_PORT", "7773"))
 LEGACY_PORT = 7723
 DAEMON_LABEL = "dev.pairling.companiond"
-GUARDIAN_LABEL = "dev.pairling.power-guardian"
 LEGACY_TOKEN_RELATIVE_PATH = ".claude/scripts/.notify-token"
-POWER_STATE_PATH = "/var/run/pairling-power-state.json"
 TAILSCALE_VARIANT = "standalone"
 AUTH_MODE = "scoped-device-bearer"
 PAIR_SERVICE_TYPE = "_pairling-pair._tcp"

package/payload/mac/companiond/runtime_manifest.py

@@ -71,7 +71,7 @@ def build_runtime_info(
     source_branch = os.environ.get("COMPANION_SOURCE_BRANCH", "unknown")
     source_dirty = None
     installed_at = os.environ.get("COMPANION_INSTALLED_AT")
-    install_root = str(script.parent.parent) if script.parent.name in {"companiond", "guardian"} else str(script.parent)
+    install_root = str(script.parent.parent) if script.parent.name == "companiond" else str(script.parent)
     source_hash = None
     verified = False
     verification_error = manifest_error
@@ -122,6 +122,7 @@ def public_runtime_info(info: dict[str, Any]) -> dict[str, Any]:
     return {
         "name": info.get("name") or RUNTIME_NAME,
         "runtime_version": info.get("runtime_version"),
+        "source_revision": info.get("source_revision"),
         "contract_version": info.get("contract_version") or CONTRACT_VERSION,
         "compat_mode": info.get("compat_mode") or COMPAT_MODE,
         "launchd_label": info.get("launchd_label") or DAEMON_LABEL,

package/payload/mac/companiond/runtime_paths.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 import os
 from pathlib import Path
 
-from runtime_contract import LEGACY_TOKEN_RELATIVE_PATH, POWER_STATE_PATH
+from runtime_contract import LEGACY_TOKEN_RELATIVE_PATH
 
 
 def home() -> Path:
@@ -69,10 +69,6 @@ def token_path() -> Path:
     return Path(os.environ.get("NOTIFY_TOKEN_FILE", str(home() / LEGACY_TOKEN_RELATIVE_PATH)))
 
 
-def guardian_state_path() -> Path:
-    return Path(os.environ.get("COMPANION_POWER_STATE_PATH", POWER_STATE_PATH))
-
-
 def legacy_scripts_root() -> Path:
     return home() / ".claude" / "scripts"
 
@@ -80,7 +76,7 @@ def legacy_scripts_root() -> Path:
 def release_root_for(script_path: str | Path) -> Path | None:
     path = Path(script_path).resolve()
     parent = path.parent
-    if parent.name in {"companiond", "guardian"}:
+    if parent.name == "companiond":
         root = parent.parent
         if (root / "manifest.json").is_file():
             return root

package/payload/mac/companiond/safety_monitor.py

@@ -26,6 +26,10 @@ SAFETY_EVENTS_MAX_READ_BYTES = max(
     64 * 1024,
     int(os.environ.get("PAIRLING_SAFETY_EVENTS_MAX_READ_BYTES", str(1024 * 1024))),
 )
+SAFETY_EVENTS_DISK_WARNING_BYTES = max(
+    1024 * 1024,
+    int(os.environ.get("PAIRLING_SAFETY_EVENTS_DISK_WARNING_BYTES", str(256 * 1024 * 1024))),
+)
 DEFAULT_STATUS = {
     "contract_version": SAFETY_BRIDGE_CONTRACT_VERSION,
     "mode": "absent",
@@ -152,11 +156,28 @@ class SafetyMonitorBridge:
         status["contract_version"] = SAFETY_CONTRACT_VERSION
         if status_error:
             status["status_error"] = status_error
-        status["status_stale"] = self._status_stale(status, loaded is not None)
+        live_artifact = self._live_artifact_status()
+        if live_artifact:
+            status["live_artifact"] = live_artifact
+            if live_artifact.get("source") == "event_log":
+                status["mode"] = "system_extension"
+                status["installed"] = True
+                status["approved"] = True
+                status["running"] = True
+                if status.get("visibility") == "unavailable":
+                    status["visibility"] = "limited"
+                status["updated_at"] = max(
+                    float(status.get("updated_at") or 0),
+                    float(live_artifact.get("events_log_mtime") or 0),
+                )
+                if status.get("summary") == DEFAULT_STATUS["summary"]:
+                    status["summary"] = "Pairling Safety Monitor has live event-log evidence."
+        status["status_stale"] = self._status_stale(status, loaded is not None or bool(live_artifact))
         status["secure_mode_state"] = self._secure_mode_state(status)
         status["guarded_mode_state"] = "guarded_deferred"
         status["system_extension_status"] = self._system_extension_status(status)
         status["capabilities"] = self._capabilities(status)
+        status["disk_usage_warning"] = self._disk_usage_warning(live_artifact)
         status["evidence_test"] = self._read_evidence_test()
         events = self.events(limit=200)
         status["event_count"] = len(events)
@@ -362,6 +383,40 @@ class SafetyMonitorBridge:
             return None, "status_unreadable"
         return (payload, None) if isinstance(payload, dict) else (None, "status_shape_invalid")
 
+    def _live_artifact_status(self) -> dict[str, Any] | None:
+        candidates: list[dict[str, Any]] = []
+        for path in self._event_paths():
+            try:
+                stat = path.stat()
+            except OSError:
+                continue
+            if not path.is_file() or stat.st_size <= 0:
+                continue
+            candidates.append({
+                "source": "event_log",
+                "events_log_path": _redact_path(str(path), self.home),
+                "events_log_bytes": int(stat.st_size),
+                "events_log_mtime": float(stat.st_mtime),
+                "path_scope": "system" if path == self.system_events_path else "user",
+            })
+        if not candidates:
+            return None
+        candidates.sort(key=lambda item: (float(item["events_log_mtime"]), int(item["events_log_bytes"])), reverse=True)
+        return candidates[0]
+
+    def _disk_usage_warning(self, live_artifact: dict[str, Any] | None) -> dict[str, Any] | None:
+        if not live_artifact:
+            return None
+        size = int(live_artifact.get("events_log_bytes") or 0)
+        if size < SAFETY_EVENTS_DISK_WARNING_BYTES:
+            return None
+        return {
+            "code": "safety_events_log_large",
+            "events_log_bytes": size,
+            "threshold_bytes": SAFETY_EVENTS_DISK_WARNING_BYTES,
+            "message": "Safety Monitor event log is large and should be rotated or rebuilt with the bounded writer.",
+        }
+
     def _normalize_event(self, raw: dict[str, Any]) -> dict[str, Any]:
         path_display = _redact_path(
             raw.get("path") or raw.get("path_display") or raw.get("redacted_path"),

package/payload/mac/connectd/internal/gateway/proxy.go

@@ -20,6 +20,7 @@ const prePairMaxBodyBytes int64 = 16 * 1024
 const pairDropSmallFileMaxBodyBytes int64 = 10 * 1024 * 1024
 const pairDropUploadChunkMaxBodyBytes int64 = 1024 * 1024
 const peerNodeHeader = "X-Pairling-Peer-Node"
+const internalTokenHeader = "X-Pairling-Internal-Token"
 
 // peerProvenanceHeader tells pairlingd how connectd identified the peer node:
 // "tagged" (the old minted tag:pairling-phone path) or "interactive" (an
@@ -233,6 +234,7 @@ func (h *Handler) rewrite(r *httputil.ProxyRequest) {
 	}
 	r.Out.Host = h.upstream.Host
 	r.Out.Header.Del("X-Forwarded-For")
+	r.Out.Header.Del(internalTokenHeader)
 	r.Out.Header.Del(peerNodeHeader)
 	r.Out.Header.Del(peerProvenanceHeader)
 	r.Out.Header.Del(funnelOriginHeader)
@@ -513,6 +515,9 @@ func Allowed(method, path string) bool {
 	if !supportedMethod(method) {
 		return false
 	}
+	if containsEscapedPathSeparator(path) {
+		return false
+	}
 	switch method {
 	case http.MethodGet:
 		return getPaths[path] || dynamicGETPath(path)
@@ -528,9 +533,17 @@ func Allowed(method, path string) bool {
 }
 
 func allowedForAnyMethod(path string) bool {
+	if containsEscapedPathSeparator(path) {
+		return false
+	}
 	return getPaths[path] || postPaths[path] || dynamicGETPath(path) || dynamicPOSTPath(path) || dynamicPUTPath(path) || dynamicDELETEPath(path)
 }
 
+func containsEscapedPathSeparator(path string) bool {
+	lower := strings.ToLower(path)
+	return strings.Contains(lower, "%2f") || strings.Contains(lower, "%5c")
+}
+
 func localUpstream(upstream *url.URL) bool {
 	host := upstream.Hostname()
 	if host == "localhost" {
@@ -672,7 +685,6 @@ var getPaths = map[string]bool{
 	"/pickers/permissions":          true,
 	"/pickers/resume":               true,
 	"/pickers/resume/preview":       true,
-	"/power-state":                  true,
 	"/provider-status":              true,
 	"/push/status":                  true,
 	"/recent-projects":              true,

package/payload/mac/connectd/internal/gateway/proxy_test.go

@@ -220,6 +220,8 @@ func TestAllowedPairDropContentRouteIsGetOnlyAndPathStrict(t *testing.T) {
 		{http.MethodPost, "/pairdrop/files/pd_0123456789abcdef0123456789abcdef/content"},
 		{http.MethodGet, "/pairdrop/files/pd_0123456789abcdef0123456789abcdef/content/extra"},
 		{http.MethodGet, "/pairdrop/files/pd_0123456789abcdef0123456789abcdef/extra/content"},
+		{http.MethodGet, "/pairdrop/files/pd_0123456789abcdef0123456789abcdef%2fextra/content"},
+		{http.MethodGet, "/pairdrop/files/pd_0123456789abcdef0123456789abcdef%5cextra/content"},
 	}
 	for _, tc := range rejected {
 		if Allowed(tc.method, tc.path) {
@@ -449,6 +451,28 @@ func TestPairlingConnectStripsForgedPeerNodeHeader(t *testing.T) {
 	}
 }
 
+func TestPairlingConnectStripsInternalTokenHeader(t *testing.T) {
+	var forwardedHeader string
+	upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		forwardedHeader = r.Header.Get("X-Pairling-Internal-Token")
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer upstream.Close()
+	handler := newTestHandlerWithMode(t, upstream.URL, 1024, nil, ExposureModePairlingConnect, nil)
+
+	req := httptest.NewRequest(http.MethodPost, "http://pairling-connect.local/send-text", strings.NewReader(`{}`))
+	req.Header.Set("Authorization", "Bearer device-token")
+	req.Header.Set("X-Pairling-Internal-Token", "forged-internal-token")
+	rec := httptest.NewRecorder()
+	handler.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d body = %s", rec.Code, rec.Body.String())
+	}
+	if forwardedHeader != "" {
+		t.Fatalf("internal token header forwarded to upstream: %q", forwardedHeader)
+	}
+}
+
 func TestPairlingConnectSetsPeerNodeHeaderFromResolver(t *testing.T) {
 	var forwardedHeader string
 	var forwardedProvenance string

package/payload/mac/install/bootstrap-first-run.sh

@@ -98,6 +98,37 @@ run_step() {
   printf '%s' "$status"
 }
 
+run_step_setup() {
+  # The setup step renders the guided screen, so its output must reach the
+  # controlling terminal while a copy is still written to setup.log for the audit
+  # record. This wrapper sends the live view to the controlling terminal through
+  # tee and writes a full transcript into the log. It reads the setup exit code
+  # from PIPESTATUS, the left side of the pipe, not tee, and emits only the
+  # status digit on its own stdout, so the surrounding command substitution reads
+  # a clean status. The terminal guard actually writes one empty line to
+  # /dev/tty, because the device node can test as writable when there is no
+  # controlling terminal. When that write fails, the wrapper falls back to the
+  # plain capture, so a headless launch still writes setup.log and never errors.
+  local name="$1"
+  shift
+  local log_file="$ARTIFACT_ROOT/$name.log"
+  set +e
+  if { : >/dev/tty; } 2>/dev/null; then
+    # PAIRLING_WIZARD tells install-runtime.sh to render even though its own
+    # stdout is piped here. tee writes the transcript to the log and sends its
+    # own stdout to the controlling terminal, so the screen is shown and the log
+    # stays a complete audit artifact. Stdin is inherited, so an interactive
+    # first-run still drives the recovery menu, which is gated on [ -t 0 ].
+    PAIRLING_WIZARD=1 "$@" 2>&1 | tee "$log_file" >/dev/tty
+    local status="${PIPESTATUS[0]}"
+  else
+    "$@" >"$log_file" 2>&1
+    local status=$?
+  fi
+  set -e
+  printf '%s' "$status"
+}
+
 run_json_step() {
   local name="$1"
   local output_file="$ARTIFACT_ROOT/$name.json"
@@ -109,7 +140,7 @@ run_json_step() {
   printf '%s' "$status"
 }
 
-setup_status="$(run_step setup "$REPO_ROOT/mac/install/install-runtime.sh" setup)"
+setup_status="$(run_step_setup setup "$REPO_ROOT/mac/install/install-runtime.sh" setup)"
 doctor_before_status="$(run_json_step doctor-before "$REPO_ROOT/mac/install/doctor.sh" --first-run --json)"
 
 pair_status="0"

package/payload/mac/install/doctor.sh

@@ -60,7 +60,6 @@ home = Path.home()
 
 PAIRLING_PORT = int(os.environ.get("PAIRLING_RUNTIME_PORT", "7773"))
 PAIRLING_LABEL = "dev.pairling.companiond"
-PAIRLING_GUARDIAN_LABEL = "dev.pairling.power-guardian"
 PAIRLING_CONNECTD_LABEL = "dev.pairling.connectd"
 PAIRLING_PTYBROKER_LABEL = "dev.pairling.ptybroker"
 TEAM_ID = os.environ.get("PAIRLING_TEAM_ID", os.environ.get("PAIRLING_CONNECTD_TEAM_ID", "965AVD34A3"))
@@ -77,7 +76,7 @@ PAIR_ROOT = APP_SUPPORT / "pair"
 USER_PLIST = home / "Library" / "LaunchAgents" / f"{PAIRLING_LABEL}.plist"
 CONNECTD_USER_PLIST = home / "Library" / "LaunchAgents" / f"{PAIRLING_CONNECTD_LABEL}.plist"
 PTYBROKER_USER_PLIST = home / "Library" / "LaunchAgents" / f"{PAIRLING_PTYBROKER_LABEL}.plist"
-SYSTEM_PLIST = Path("/Library/LaunchDaemons") / f"{PAIRLING_GUARDIAN_LABEL}.plist"
+CLAUDE_INJECTOR = home / "Applications" / "ClaudeInjector.app" / "Contents" / "MacOS" / "ClaudeInjector"
 
 sys.path.insert(0, str(repo_root / "mac" / "companiond"))
 from pairling_connectd_status import fetch_connectd_status, redacted_connectd_summary
@@ -175,6 +174,8 @@ def detected_tailnet_ip() -> str | None:
 
 
 def permission_readiness() -> dict:
+    helper_installed = CLAUDE_INJECTOR.exists()
+    grantee_path = str(CLAUDE_INJECTOR if helper_installed else Path("/usr/bin/osascript"))
     return {
         "ios_local_network": {
             "required_for": ["bonjour_pairing", "lan_route_validation"],
@@ -187,10 +188,16 @@ def permission_readiness() -> dict:
         "mac_accessibility": {
             "required_for": ["terminal_ui_synthesis"],
             "status": "not_required_until_terminal_control",
+            "grantee_path": grantee_path,
+            "helper_installed": helper_installed,
+            "helper_path": str(CLAUDE_INJECTOR),
+            "doctor_probe": "reports_required_grantee",
         },
         "mac_automation": {
             "required_for": ["terminal_app_control"],
             "status": "not_required_by_default",
+            "grantee_path": grantee_path,
+            "doctor_probe": "reports_required_grantee",
         },
         "privacy_database": "not_modified",
     }
@@ -250,6 +257,37 @@ def ptybroker_status_rpc() -> tuple[dict | None, str | None]:
         return None, f"{type(exc).__name__}: {exc}"
 
 
+def safety_monitor_status() -> dict:
+    # Report the live SafetyMonitorBridge status, not a guess from local files.
+    # The bridge is imported from the staged companiond, the same copy the daemon
+    # runs. When no runtime is staged or the import fails, report a structured
+    # value with installed false, so the doctor JSON stays pure and never leaks a
+    # traceback. The bridge itself defaults to installed false when the future
+    # PairlingSafety.app is not present, which is today's true value.
+    try:
+        sys.path.insert(0, str(CURRENT / "companiond"))
+        from safety_monitor import SafetyMonitorBridge
+        bridge = SafetyMonitorBridge(APP_SUPPORT, home)
+        status = bridge.status()
+        return {
+            "installed": bool(status.get("installed")),
+            "full_disk_access": status.get("full_disk_access") or "unknown",
+            "system_extension_status": status.get("system_extension_status"),
+            "secure_mode_state": status.get("secure_mode_state"),
+            "live_artifact": status.get("live_artifact"),
+            "disk_usage_warning": status.get("disk_usage_warning"),
+            "summary": status.get("summary") or "",
+            "source": "live_bridge_status",
+        }
+    except Exception as exc:
+        return {
+            "installed": False,
+            "full_disk_access": "unknown",
+            "source": "live_bridge_status",
+            "error": str(exc)[:200],
+        }
+
+
 def ptybroker_deployment_status(*, launchd_loaded: bool) -> dict:
     desired = desired_ptybroker_identity()
     base = {
@@ -387,9 +425,8 @@ if manifest:
         "daemon_label": launchd.get("daemon_label"),
         "ptybroker_label": launchd.get("ptybroker_label"),
         "connectd_label": launchd.get("connectd_label"),
-        "guardian_label": launchd.get("guardian_label"),
     }
-    add("launchd_labels", launchd.get("daemon_label") == PAIRLING_LABEL and launchd.get("ptybroker_label") == PAIRLING_PTYBROKER_LABEL and launchd.get("connectd_label") == PAIRLING_CONNECTD_LABEL and launchd.get("guardian_label") == PAIRLING_GUARDIAN_LABEL, "error", "Manifest launchd labels are Pairling labels.", launchd_evidence)
+    add("launchd_labels", launchd.get("daemon_label") == PAIRLING_LABEL and launchd.get("ptybroker_label") == PAIRLING_PTYBROKER_LABEL and launchd.get("connectd_label") == PAIRLING_CONNECTD_LABEL, "error", "Manifest launchd labels are Pairling labels.", launchd_evidence)
     mismatches = []
     for item in manifest.get("files") or []:
         rel = item.get("path")
@@ -413,15 +450,13 @@ else:
 
 compile_targets = [
     repo_root / "mac" / "install" / "render-launchd.py",
-    repo_root / "mac" / "guardian" / "guardian_contract.py",
-    repo_root / "mac" / "guardian" / "companion-power-guardian.py",
 ]
 compile_errors = []
 for target in compile_targets:
     code, out, err = run(["python3", "-m", "py_compile", str(target)])
     if code != 0:
         compile_errors.append(f"{target}: {err or out}")
-add("lifecycle_sources_compile", not compile_errors, "error", "Lifecycle/guardian sources compile." if not compile_errors else "Lifecycle/guardian compile failed.", compile_errors)
+add("lifecycle_sources_compile", not compile_errors, "error", "Lifecycle sources compile." if not compile_errors else "Lifecycle compile failed.", compile_errors)
 
 ok, evidence = writable_dir(APP_SUPPORT)
 add("app_support_writable", ok, "error", "App support directory is writable.", evidence)
@@ -545,12 +580,6 @@ try:
 except Exception as exc:
     add("ptybroker_launchagent_plist", False, "error", f"Pairling PTY broker LaunchAgent plist unreadable: {type(exc).__name__}: {exc}", str(PTYBROKER_USER_PLIST))
 
-try:
-    payload = load_plist(SYSTEM_PLIST)
-    add("guardian_plist", payload.get("Label") == PAIRLING_GUARDIAN_LABEL, "warning", "Pairling guardian LaunchDaemon is rendered/installed.", {"label": payload.get("Label")})
-except Exception as exc:
-    add("guardian_plist", False, "warning", f"Pairling guardian LaunchDaemon is not installed: {type(exc).__name__}: {exc}", str(SYSTEM_PLIST))
-
 code, out, err = run(["launchctl", "print", f"gui/{os.getuid()}/{PAIRLING_LABEL}"])
 add("launchagent_loaded", code == 0 and "state = running" in out, "error", "Pairling LaunchAgent is running." if code == 0 else "Pairling LaunchAgent is not loaded.", (out or err)[:2000])
 add("launchagent_loaded_from_current", str(CURRENT / "companiond" / "pairlingd.py") in out, "error", "Loaded Pairling LaunchAgent uses runtime/current.", out[:2000])
@@ -790,13 +819,13 @@ first_run = {
 result = {
     "ok": not errors,
     "product": "Pairling",
+    "safety_monitor": safety_monitor_status(),
     "schema_version": 1,
     "contract_version": "pairling-runtime-v1",
     "runtime": {
         "name": "pairlingd",
         "port": PAIRLING_PORT,
         "launchd_label": PAIRLING_LABEL,
-        "guardian_label": PAIRLING_GUARDIAN_LABEL,
     },
     "ptybroker": ptybroker_deployment,
     "paths": {