brainlayer 1.5.63__tar.gz → 1.5.65__tar.gz

{brainlayer-1.5.63 → brainlayer-1.5.65}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: brainlayer
-Version: 1.5.63
+Version: 1.5.65
 Summary: Persistent local memory for AI agents — 16 BrainBar MCP tools, semantic search, knowledge graph, SQLite
 Project-URL: Homepage, https://brainlayer.etanheyman.com
 Project-URL: Repository, https://github.com/EtanHey/brainlayer

{brainlayer-1.5.63 → brainlayer-1.5.65}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "brainlayer"
-version = "1.5.63"
+version = "1.5.65"
 description = "Persistent local memory for AI agents — 16 BrainBar MCP tools, semantic search, knowledge graph, SQLite"
 license = {text = "Apache-2.0"}
 readme = "README.md"

{brainlayer-1.5.63 → brainlayer-1.5.65}/server.json

@@ -3,7 +3,7 @@
   "name": "io.github.etanhey/brainlayer",
   "title": "BrainLayer",
   "description": "Persistent local memory for AI agents \u2014 semantic search, knowledge graph, and 16 BrainBar MCP tools with ToolAnnotations over SQLite.",
-  "version": "1.5.63",
+  "version": "1.5.65",
   "websiteUrl": "https://brainlayer.etanheyman.com",
   "repository": {
     "url": "https://github.com/EtanHey/brainlayer",
@@ -14,7 +14,7 @@
       "registryType": "pypi",
       "registryBaseUrl": "https://pypi.org",
       "identifier": "brainlayer",
-      "version": "1.5.63",
+      "version": "1.5.65",
       "runtimeHint": "pipx",
       "transport": {
         "type": "stdio"

{brainlayer-1.5.63 → brainlayer-1.5.65}/src/brainlayer/__init__.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-__version__ = "1.5.63"
+__version__ = "1.5.65"
 # Git sha the distributed package was built from; stamped by the release build, None in a source tree.
 # scripts/sprint_gate.py reads it in "keg" mode to prove the served package is the code under test.
 # No runtime `str | None` annotation: launchd/install.sh imports this under /usr/bin/python3 (3.9).

brainlayer-1.5.65/src/brainlayer/_build.py

@@ -0,0 +1 @@
+BUILD_SHA = "c8981703b52a14f33ca46b861c245478d628e72c"

brainlayer-1.5.65/src/brainlayer/brainbar_activation.py

@@ -0,0 +1,202 @@
+"""Explicit, single-attempt cask activation after Homebrew returns."""
+
+import fcntl
+import math
+import os
+import plistlib
+import re
+import subprocess
+import sys
+import time
+from pathlib import Path
+from xml.parsers.expat import ExpatError
+
+from .brainbar_identity import JOBS, running_bundle_matches
+from .setup import get_current_mcp_bridge_bin, verify_mcp_transport
+
+
+def _activate(agents: Path, *, timeout_seconds: float = 90.0, verify: bool = True, automatic: bool = False) -> dict:
+    """Replace only the cask's two labels; unload attempts on failure, never relaunch."""
+    attempted = []
+    mutated = False
+    stage = "preflight"
+    report = {"ok": False, "service_ready": False, "rollback_attempted": False, "cleanup_errors": []}
+
+    def launchctl(*args, timeout=10.0):
+        return subprocess.run(["/bin/launchctl", *args], capture_output=True, text=True, timeout=timeout, check=False)
+
+    try:
+        deadline = time.monotonic() + timeout_seconds
+        if sys.platform != "darwin":
+            raise ValueError("activation requires macOS")
+        if not math.isfinite(timeout_seconds) or timeout_seconds <= 0:
+            raise ValueError("activation timeout must be finite and positive")
+        socket = Path("/tmp/brainbar.sock")
+        for key in ("BRAINLAYER_MCP_SOCKET", "MCPLAYER_BRAINLAYER_FRONT"):
+            if os.environ.get(key) and os.environ[key] != str(socket):
+                raise ValueError(f"cask activation requires {key} to be unset or {socket}")
+        bridge = get_current_mcp_bridge_bin()
+        if verify and not bridge:
+            raise ValueError("installed brainlayer-mcp-stdio-bridge is missing")
+        bundles = set()
+        for label, binary in JOBS:
+            with (agents / f"{label}.plist").open("rb") as stream:
+                plist = plistlib.load(stream)
+            if not isinstance(plist, dict):
+                raise ValueError(f"invalid installed cask plist: {label}")
+            arguments = plist.get("ProgramArguments", [])
+            executable = (
+                Path(arguments[0])
+                if isinstance(arguments, list) and len(arguments) == 1 and isinstance(arguments[0], str)
+                else Path()
+            )
+            if (
+                plist.get("Label") != label
+                or not executable.is_absolute()
+                or executable.name != binary
+                or executable.parent.name != "MacOS"
+                or executable.parent.parent.name != "Contents"
+                or executable.parents[2].name != "BrainBar.app"
+                or not os.access(executable, os.X_OK)
+            ):
+                raise ValueError(f"invalid installed cask plist: {label}")
+            bundles.add(executable.parents[2])
+        if len(bundles) != 1:
+            raise ValueError("BrainBar labels must use the same installed app")
+        domain = f"gui/{os.getuid()}"
+
+        def remaining():
+            seconds = deadline - time.monotonic()
+            if seconds <= 0:
+                raise TimeoutError("activation deadline exceeded")
+            return seconds
+
+        stage = "disabled"
+        disabled = launchctl("print-disabled", domain, timeout=min(10, remaining()))
+        if disabled.returncode:
+            raise RuntimeError("could not inspect disabled launchd labels")
+        for label, _ in JOBS:
+            if re.search(r'"' + re.escape(label) + r'"\s*=>\s*true', disabled.stdout):
+                raise RuntimeError(f"launchd label explicitly disabled: {label}")
+        stage = "running_probe"
+        if running_bundle_matches(next(iter(bundles)), timeout=min(10, remaining())):
+            # A failed probe of this already-running bundle never authorizes stopping it.
+            tool_count = verify_mcp_transport(bridge_command=bridge, timeout_seconds=remaining()) if verify else None
+            return {
+                **report,
+                "ok": True,
+                "service_ready": verify,
+                "stage": "already_running",
+                "reason": "",
+                "tool_count": tool_count,
+            }
+
+        def brew_guard():
+            if automatic:
+                from .brainbar_auto_activation import brew_active
+
+                if brew_active():
+                    raise RuntimeError("active Homebrew run; automatic activation deferred")
+
+        brew_guard()
+        for label, _ in JOBS:
+            brew_guard()
+            stage = f"launch:{label}"
+            target = f"{domain}/{label}"
+            current = launchctl("print", target, timeout=min(10, remaining()))
+            if current.returncode not in (0, 113):
+                raise RuntimeError(f"could not inspect {label}: {current.returncode}")
+            if current.returncode == 0:
+                mutated = True
+                if launchctl("bootout", target, timeout=min(10, remaining())).returncode != 0:
+                    raise RuntimeError(f"could not unload {label}")
+                while True:
+                    state = launchctl("print", target, timeout=min(10, remaining()))
+                    if state.returncode == 113:
+                        break
+                    if state.returncode != 0:
+                        raise RuntimeError(f"could not observe teardown: {label}")
+                    time.sleep(min(0.1, remaining()))
+            brew_guard()
+            attempted.append(target)
+            mutated = True
+            result = launchctl("bootstrap", domain, str(agents / f"{label}.plist"), timeout=min(10, remaining()))
+            if result.returncode:
+                if launchctl("print", target, timeout=min(10, remaining())).returncode != 0:
+                    raise RuntimeError(f"could not bootstrap {label}: {result.returncode}")
+        stage = "socket"
+        if verify:
+            while not socket.is_socket():
+                time.sleep(min(0.1, remaining()))
+        stage = "mcp"
+        tool_count = verify_mcp_transport(bridge_command=bridge, timeout_seconds=remaining()) if verify else None
+        if verify:
+            stage = "running_identity"
+            if not running_bundle_matches(next(iter(bundles)), timeout=min(10, remaining())):
+                raise RuntimeError("MCP responded but running executables do not match the installed bundle")
+        return {
+            **report,
+            "ok": True,
+            "service_ready": verify,
+            "stage": "verified" if verify else "started_unverified",
+            "reason": "",
+            "tool_count": tool_count,
+        }
+    except (
+        OSError,
+        ValueError,
+        RuntimeError,
+        subprocess.SubprocessError,
+        plistlib.InvalidFileException,
+        ExpatError,
+    ) as exc:
+        if automatic and not mutated and "active Homebrew run" in str(exc):
+            return {**report, "stage": "deferred", "reason": str(exc)}
+        # KeepAlive jobs must not keep retrying after failed activation. No automatic
+        # old-bundle rollback, config rewrite, or second bootstrap is attempted.
+        for target in reversed(attempted):
+            try:
+                if launchctl("bootout", target).returncode != 0:
+                    report["cleanup_errors"].append(target)
+            except (OSError, subprocess.SubprocessError):
+                report["cleanup_errors"].append(target)
+        return {**report, "stage": stage, "reason": str(exc)}
+
+
+def activate(agents: Path, *, timeout_seconds: float = 90.0, verify: bool = True, automatic: bool = False) -> dict:
+    try:
+        if not math.isfinite(timeout_seconds) or timeout_seconds <= 0:
+            raise ValueError("activation timeout must be finite and positive")
+        deadline = time.monotonic() + timeout_seconds
+        if os.environ.get("BRAINLAYER_FORBID_BRAINBAR_SOCKET") and agents == Path.home() / "Library/LaunchAgents":
+            raise ValueError("test guard forbids installed BrainBar activation")
+        # Shared by manual commands and the supervisor child; no concurrent restart.
+        with (agents / ".brainbar-activation.lock").open("a") as lock:
+            while True:
+                seconds = deadline - time.monotonic()
+                if seconds <= 0:
+                    raise TimeoutError("activation deadline exceeded waiting for activation lock")
+                try:
+                    fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                    break
+                except BlockingIOError:
+                    if automatic:
+                        return {
+                            "ok": False,
+                            "stage": "deferred",
+                            "reason": "activation already in progress",
+                            "service_ready": False,
+                            "rollback_attempted": False,
+                            "cleanup_errors": [],
+                        }
+                    time.sleep(min(0.1, seconds))
+            return _activate(agents, timeout_seconds=deadline - time.monotonic(), verify=verify, automatic=automatic)
+    except (OSError, ValueError) as exc:
+        return {
+            "ok": False,
+            "stage": "activation_lock",
+            "reason": str(exc),
+            "service_ready": False,
+            "rollback_attempted": False,
+            "cleanup_errors": [],
+        }

brainlayer-1.5.65/src/brainlayer/brainbar_auto_activation.py

@@ -0,0 +1,210 @@
+"""One bounded supervisor pass; durable per-build suppression survives daemon restarts."""
+
+import argparse
+import fcntl
+import json
+import os
+import plistlib
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from .brainbar_identity import JOBS, app_identity, loaded, running_bundle_matches
+from .deploy_drift import _atomic_write_json
+from .job_alerts import active_alerts, report
+from .pipeline.secret_scrub import scrub_secrets
+
+
+class ProcessScanUnavailable(Exception):
+    """Detection is unknown; only the safe exception class name may escape."""
+
+
+def process_table():
+    result = subprocess.run(
+        ["/bin/ps", "-axo", "pid=,ppid=,comm=,args="], capture_output=True, text=True, check=True, timeout=5
+    )
+    return result.stdout
+
+
+def brew_processes():
+    # Include brew's Ruby entrypoint and Homebrew-owned child executables, even
+    # after reparenting. Unknown/unreadable process tables defer activation.
+    rows = process_table().splitlines()
+    matches = []
+    for row in rows:
+        fields = row.split(None, 3)
+        if len(fields) != 4 or not fields[0].isascii() or not fields[0].isdecimal():
+            raise ValueError("unreadable process table")
+        tokens = fields[3].split()
+        if Path(fields[2]).name == "brew" or any(
+            Path(token).name in {"brew", "brew.rb"} or "/Homebrew/" in token or "/homebrew/Library/Homebrew/" in token
+            for token in tokens
+        ):
+            # argv is detection-only: Homebrew curl headers can carry tokens.
+            executable = scrub_secrets(Path(fields[2]).name).text[:128]
+            matches.append(f"{fields[0]} {executable}")
+    return matches
+
+
+def brew_active():
+    return bool(brew_processes())
+
+
+class AutoActivator:
+    def __init__(self, agents: Path, state: Path):
+        self.agents, self.state = agents, state
+
+    def tick(self):
+        self.state.parent.mkdir(parents=True, exist_ok=True)
+        with self.state.with_suffix(".lock").open("a") as lock:
+            try:
+                fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            except BlockingIOError:
+                return
+            failures = self.state.with_suffix(".scan.json")
+            try:
+                self._tick()
+            except ProcessScanUnavailable as exc:
+                prior = json.loads(failures.read_text()) if failures.exists() else {}
+                count = min(prior.get("failures", 0) + 1, 12)
+                _atomic_write_json(failures, {"failures": count})
+                if count >= 12:
+                    try:
+                        absent = all(loaded(label).returncode == 113 for label, _ in JOBS)
+                    except (OSError, subprocess.SubprocessError, RuntimeError):
+                        return  # Unknown launchd state is not evidence BrainBar is down.
+                    if absent:
+                        report("brainbar-activation", f"BrainBar activation process scan failed for >=12 ticks: {exc}")
+
+    def _defer_for_brew(self):
+        # Separate from the per-build attempt: brew may have removed both plists.
+        path = self.state.with_suffix(".brew.json")
+        prior = json.loads(path.read_text()) if path.exists() else {}
+        try:
+            processes = brew_processes()
+        except (OSError, subprocess.SubprocessError) as exc:
+            raise ProcessScanUnavailable(type(exc).__name__) from None
+        # Recover before activation can report a new failure on the same alert key.
+        self.state.with_suffix(".scan.json").unlink(missing_ok=True)
+        reason = active_alerts().get("brainbar-activation", "")
+        migration = self.state.with_suffix(".scan-migration.json")
+        migrate_legacy = not migration.exists()
+        if migrate_legacy:
+            # Consume even without a legacy alert, before later work can raise an OSError.
+            _atomic_write_json(migration, {"completed": True})
+        if (migrate_legacy and reason.startswith("BrainBar activation monitor refused: [Errno")) or reason.startswith(
+            (
+                "BrainBar activation process scan failed for >=12 ticks:",
+                "BrainBar activation monitor refused: Command '['/bin/ps',",
+            )
+        ):
+            report("brainbar-activation", None)
+        absent = bool(processes) and all(loaded(label).returncode == 113 for label, _ in JOBS)
+        if not absent:
+            if prior:
+                path.unlink()
+                if prior.get("alerted"):
+                    report("brainbar-activation-brew", None)
+        else:
+            now = time.time()
+            since = prior.get("since", now)
+            if since > now:
+                since, prior = now, {}
+            alerted = prior.get("alerted", False)
+            if now - since > 600 and not alerted:
+                names = processes[:5]
+                if len(processes) > 5:
+                    names.append(f"+{len(processes) - 5} more")
+                report(
+                    "brainbar-activation-brew",
+                    "BrainBar activation deferred by Homebrew for >10 minutes: " + "; ".join(names),
+                )
+                alerted = True
+            _atomic_write_json(path, {"since": since, "alerted": alerted})
+        return bool(processes)
+
+    def _tick(self):
+        if self._defer_for_brew():
+            return
+        apps = set()
+        for label, _ in JOBS:
+            path = self.agents / f"{label}.plist"
+            if not path.is_file():
+                return
+            with path.open("rb") as stream:
+                plist = plistlib.load(stream)
+            apps.add(Path(plist["ProgramArguments"][0]).parents[2])
+        if len(apps) != 1:
+            raise ValueError("cask plists use different bundles")
+        app = apps.pop()
+        if not (app / "Contents/Info.plist").is_file():
+            return
+        identity = {"app": str(app), **app_identity(app)}
+        prior = json.loads(self.state.read_text()) if self.state.exists() else {}
+        if prior.get("identity") == identity and prior.get("stage") == "ready":
+            return
+        states = [loaded(label).returncode for label, _ in JOBS]
+        if all(code == 0 for code in states) and running_bundle_matches(app):
+            _atomic_write_json(self.state, {"identity": identity, "stage": "ready"})
+            report("brainbar-activation", None)
+            return
+        if prior.get("identity") == identity:
+            if prior.get("stage") == "attempted":
+                reason = "BrainBar activation was interrupted; run brainlayer brainbar activate"
+                report("brainbar-activation", reason)
+                _atomic_write_json(self.state, {"identity": identity, "stage": "failed", "reason": reason})
+            return
+        if any(code == 0 for code in states) or self._defer_for_brew():
+            return
+        # Write before launching: crash/restart is never permission to repeat.
+        _atomic_write_json(self.state, {"identity": identity, "stage": "attempted"})
+        try:
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    "-m",
+                    "brainlayer",
+                    "brainbar",
+                    "activate",
+                    "--verify",
+                    "--automatic",
+                    "--timeout",
+                    "90",
+                ],
+                capture_output=True,
+                text=True,
+                timeout=110,
+                check=False,
+            )
+            receipt = json.loads(result.stdout)
+            if receipt.get("stage") == "deferred":
+                self.state.unlink()
+                return
+            ok = result.returncode == 0 and receipt.get("ok") is True
+            reason = (
+                None
+                if ok
+                else f"BrainBar activation failed: {receipt.get('reason', 'no successful receipt')}; run brainlayer brainbar activate"
+            )
+        except (OSError, ValueError, subprocess.SubprocessError) as exc:
+            ok, reason = False, f"BrainBar activation failed: {exc}; run brainlayer brainbar activate"
+        _atomic_write_json(self.state, {"identity": identity, "stage": "ready" if ok else "failed", "reason": reason})
+        report("brainbar-activation", reason)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--state", type=Path, required=True)
+    args = parser.parse_args()
+    if os.environ.get("BRAINLAYER_FORBID_BRAINBAR_SOCKET"):
+        raise SystemExit("test guard forbids automatic installed BrainBar activation")
+    try:
+        AutoActivator(Path.home() / "Library/LaunchAgents", args.state).tick()
+    except Exception as exc:
+        report("brainbar-activation", f"BrainBar activation monitor refused: {exc}")
+        raise SystemExit(1) from exc
+
+
+if __name__ == "__main__":
+    main()

brainlayer-1.5.65/src/brainlayer/brainbar_identity.py

@@ -0,0 +1,91 @@
+"""Bind loaded cask PIDs to the executable vnodes in the installed bundle."""
+
+import os
+import plistlib
+import re
+import subprocess
+import time
+from pathlib import Path
+
+JOBS = (("com.brainlayer.brainbar-daemon", "BrainBarDaemon"), ("com.brainlayer.brainbar", "BrainBar"))
+
+
+def app_identity(app: Path) -> dict:
+    with (app / "Contents/Info.plist").open("rb") as stream:
+        info = plistlib.load(stream)
+    if not isinstance(info, dict):
+        raise ValueError("installed BrainBar identity is not a dictionary")
+    version = info.get("CFBundleShortVersionString")
+    commit = info.get("GitCommit", "")
+    if not isinstance(version, str) or not version or not isinstance(commit, str):
+        raise ValueError("installed BrainBar identity is missing")
+    executable = (app / "Contents/MacOS/BrainBar").stat()
+    return {
+        "version": version,
+        "git_commit": commit,
+        "executable_dev": executable.st_dev,
+        "executable_ino": executable.st_ino,
+    }
+
+
+def executable_snapshot(info):
+    return (info.st_dev, info.st_ino, info.st_size, info.st_mtime_ns)
+
+
+def run(args, timeout=10):
+    return subprocess.run(args, capture_output=True, text=True, check=False, timeout=timeout)
+
+
+def loaded(label, timeout=10):
+    result = run(["/bin/launchctl", "print", f"gui/{os.getuid()}/{label}"], timeout)
+    if result.returncode not in (0, 113):
+        raise RuntimeError(f"launchctl print failed for {label}: {result.returncode}")
+    return result
+
+
+def running_bundle_matches(app: Path, *, timeout=10) -> bool:
+    deadline = time.monotonic() + timeout
+
+    def remaining():
+        value = deadline - time.monotonic()
+        if value <= 0:
+            raise TimeoutError("running-bundle inspection deadline exceeded")
+        return value
+
+    for label, binary in JOBS:
+        state = loaded(label, remaining())
+        pid = re.search(r"(?m)^\s*pid\s*=\s*(\d+)\s*$", state.stdout)
+        executable = app / "Contents/MacOS" / binary
+        program = re.search(r"(?m)^\s*program\s*=\s*(.*?)\s*$", state.stdout)
+        if state.returncode or not pid or not program or program[1].strip('"') != str(executable):
+            return False
+        result = run(["/usr/sbin/lsof", "-a", "-p", pid[1], "-d", "txt", "-F", "Din"], remaining())
+        if result.returncode:
+            return False
+        device = inode = None
+        matched = False
+        info = executable.stat()
+        for line in result.stdout.splitlines():
+            if line.startswith("f"):
+                device = inode = None
+            elif line.startswith("D"):
+                device = int(line[1:], 16)
+            elif line.startswith("i"):
+                inode = int(line[1:])
+            elif line == f"n{executable}":
+                matched = device == info.st_dev and inode == info.st_ino
+                if matched:
+                    break
+        if not matched:
+            return False
+        # Refuse PID/label replacement while the vnode snapshot was inspected.
+        final = loaded(label, remaining())
+        final_pid = re.search(r"(?m)^\s*pid\s*=\s*(\d+)\s*$", final.stdout)
+        if (
+            final.returncode
+            or not final_pid
+            or final_pid[1] != pid[1]
+            or executable_snapshot(executable.stat()) != executable_snapshot(info)
+        ):
+            return False
+    return True

{brainlayer-1.5.63 → brainlayer-1.5.65}/src/brainlayer/cli/__init__.py

@@ -76,6 +76,54 @@ def backup_auth_command(
         raise typer.Exit(1)
 
 
+brainbar_app = typer.Typer(help="Activate the installed BrainBar cask after Homebrew returns")
+app.add_typer(brainbar_app, name="brainbar")
+
+
+@brainbar_app.command("activate")
+def brainbar_activate_command(
+    verify: bool = typer.Option(True, "--verify/--no-verify", help="Require real MCP verification after activation."),
+    automatic: bool = typer.Option(False, "--automatic", hidden=True),
+    timeout: float = typer.Option(
+        90.0,
+        "--timeout",
+        envvar="BRAINLAYER_BRAINBAR_ACTIVATION_TIMEOUT_S",
+        help="Startup and MCP deadline in seconds; separate from setup's verification deadline.",
+    ),
+) -> None:
+    """Activate the cask's two LaunchAgents once and emit a JSON receipt."""
+    from ..brainbar_activation import activate
+
+    report = activate(
+        Path.home() / "Library" / "LaunchAgents", timeout_seconds=timeout, verify=verify, automatic=automatic
+    )
+    if report["ok"] and verify and not automatic:
+        from ..job_alerts import report as report_alert
+
+        report_alert("brainbar-activation", None)
+    typer.echo(json.dumps(report, sort_keys=True))
+    if not report["ok"]:
+        raise typer.Exit(1)
+
+
+@brainbar_app.command("verify-running")
+def brainbar_verify_running_command(
+    app_path: Path = typer.Option(Path("/Applications/BrainBar.app"), "--app"),
+) -> None:
+    """Read-only check that both running executables belong to this installed build."""
+    from ..brainbar_identity import app_identity, running_bundle_matches
+
+    try:
+        identity = app_identity(app_path)
+        ok = running_bundle_matches(app_path)
+        report = {"ok": ok, **identity, "reason": "" if ok else "running_bundle_mismatch"}
+    except (OSError, ValueError, RuntimeError, subprocess.SubprocessError) as exc:
+        report = {"ok": False, "reason": str(exc)}
+    typer.echo(json.dumps(report, sort_keys=True))
+    if not report["ok"]:
+        raise typer.Exit(1)
+
+
 @jobs_app.command("restart")
 def jobs_restart_command(
     all_jobs: bool = typer.Option(False, "--all", help="Select loaded BrainLayer jobs."),

{brainlayer-1.5.63 → brainlayer-1.5.65}/src/brainlayer/supervisor_jobs.py

@@ -12,6 +12,7 @@ import json
 import math
 import os
 import stat
+import sys
 import time
 from pathlib import Path
 
@@ -123,6 +124,34 @@ def load_components(path: Path, socket_path: Path) -> dict[str, Component]:
         if interval and not run_at_load:
             child.retry_at = time.monotonic() + interval
         components[ALIASES[label]] = child
+    return with_brainbar_monitor(components, socket_path)
+
+
+def with_brainbar_monitor(components, path):
+    if sys.platform == "darwin":
+        observability_env = components.get("observability", Component(("unused",))).env
+        monitor_env = {
+            key: observability_env[key]
+            for key in ("BRAINLAYER_DB", "BRAINLAYER_JOB_ALERT_PATH")
+            if key in observability_env
+        }
+        if "BRAINLAYER_FORBID_BRAINBAR_SOCKET" in os.environ:
+            monitor_env["BRAINLAYER_FORBID_BRAINBAR_SOCKET"] = os.environ["BRAINLAYER_FORBID_BRAINBAR_SOCKET"]
+        components["brainbar-activation"] = Component(
+            (
+                sys.executable,
+                "-m",
+                "brainlayer.brainbar_auto_activation",
+                "--state",
+                str(path.with_name("brainbar-activation.json")),
+            ),
+            env=monitor_env,
+            interval=5,
+            run_timeout=180,
+            exit_timeout=2,
+            stdout=path.with_name("brainbar-activation.log"),
+            stderr=path.with_name("brainbar-activation.err.log"),
+        )
     return components