Pre-Flight: a Checklist the Machine Checks

import re
from pathlib import PurePosixPath

# The rules of backend/services/onair_preflight.py and frontend/src/lib/onairPreflight.ts.
SCREENFLOW_RECORDER = "screenflowrecorder"   # exists exactly while ScreenFlow records
SCREENFLOW_APP = "screenflow"
CARD_TURNS = 2                               # his first turn hears the checklist, the second answers it
ITEM = re.compile(r"^\s*\d+[.)]\s+(?P<text>\S.*?)\s*$")
NAMES_SCREENFLOW = re.compile(r"screen\s*flow", re.IGNORECASE)

CHECKLIST = """[On Air: the opening checklist]
Before anything else, run Dad's recording checklist with him:
1. ScreenFlow is running and recording every display he needs.
2. Logic Pro is recording his voice.
3. The camera is on.
Ask, then wait for his answer."""


def checklist_items(instruction: str) -> list[str]:
    """The card is the very text she asks from: its numbered lines."""
    return [m.group("text") for line in instruction.splitlines() if (m := ITEM.match(line))]


def executable(command: str) -> str:
    """The full path's last part, a bundle-id prefix left off. The short process
    name is cut to 16 characters ("screenflowrecord"), so read the path."""
    name = PurePosixPath(command.strip()).name.lower()
    return name.rsplit(".", 1)[-1] if "." in name else name


def screenflow(items: list[str], commands: list[str] | None) -> dict | None:
    if not any(NAMES_SCREENFLOW.search(item) for item in items):
        return None                          # a show recorded some other way: no check, no alarm
    if commands is None:                     # a screen on another Mac: never a guess
        return {"checked": False, "reason": "cannot be checked from here"}
    names = {executable(c) for c in commands if c.strip()}
    return {"checked": True, "recording": SCREENFLOW_RECORDER in names, "app_running": SCREENFLOW_APP in names}


def alarm(state: dict | None) -> bool:
    """Only a KNOWN 'not recording' rings it. Not knowing never does."""
    return bool(state) and state["checked"] and state["recording"] is False


def card_shows(items: list[str], state: dict | None, turns: int) -> bool:
    return bool(items) and (alarm(state) or turns < CARD_TURNS)


items = checklist_items(CHECKLIST)
# Illustrative process paths, the shape `ps -axo comm=` prints.
app = "/Applications/ScreenFlow.app/Contents/MacOS/ScreenFlow"
recorder = "/Applications/ScreenFlow.app/Contents/MacOS/screenflowrecorder"
helper = "/Library/PrivilegedHelperTools/net.telestream.screenflowhelper"
for label, commands, turns in (
    ("not open, his first turn", ["/usr/sbin/cfprefsd", helper], 0),
    ("open, not recording, third turn", [app, helper], 2),
    ("recording, first turn", [app, recorder, helper], 0),
    ("recording, third turn", [app, recorder, helper], 2),
    ("screen on another Mac", None, 0),
):
    state = screenflow(items, commands)
    print(f"{label:32s} card={card_shows(items, state, turns)!s:5s} warning={alarm(state)!s:5s} {state}")
print("no ScreenFlow on the list:", screenflow(items[1:], [app, helper]))

export const PREFLIGHT = {
  /** How often the screen asks: the recorder appears within a second of Record. */
  pollMs: 2000,
  /** While ScreenFlow is not recording the warning plays again this often,
   *  so the screen never settles into looking fine. */
  warningEveryMs: 3000,
  /** His turns the card stays for: the first opens the broadcast and hears
   *  her checklist, the second answers it. */
  cardTurns: 2,
} as const;

/** The alarm rings only when ScreenFlow is on his checklist and known not to
 *  be recording. Not knowing (a screen on another Mac, a server restarting)
 *  never rings it. */
export function screenflowAlarm(state: PreflightState | null): boolean {
  return !!state && state.screenflowItem !== null && !!state.screenflow?.checked && state.screenflow.recording === false;
}

/** His turns since On Air came on: the messages there then are the baseline. */
export function turnsSince(messages: ReadonlyArray<{ id: string; role: string }>, baseline: ReadonlySet<string>): number {
  return messages.filter(message => message.role === 'user' && !baseline.has(message.id)).length;
}

/** The card stands from the moment On Air comes on until his second turn
 *  (the first hears her checklist, the second answers it), and again for as
 *  long as ScreenFlow is not recording. A checklist with no numbered items
 *  has no card. */
export function showPreflightCard(state: PreflightState | null, turns: number): boolean {
  return !!state && state.items.length > 0 && (screenflowAlarm(state) || turns < PREFLIGHT.cardTurns);
}