Blame for artifacts/taskpack/linux/benchlab.py

# SPDX-License-Identifier: FSL-1.1-MIT
# Copyright (c) 2026 Cua AI, Inc.

from __future__ import annotations

import argparse
import ctypes
import json
import os
import sys
import time
from pathlib import Path

import gi

gi.require_version("Gtk", "3.0")
gi.require_version("Gdk", "3.0")
from gi.repository import Gdk, GLib, Gtk

sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "probes" / "_common"))
import benchlab_common as C

MODES = ("listdrag", "hover", "tooltip", "irmodal", "irbanner", "irunsaved", "irconsent")


class Lab:
    def __init__(self, args: argparse.Namespace) -> None:
        ctypes.CDLL(None).prctl(15, b"BenchLab", 0, 0, 0)
        GLib.set_prgname("BenchLab")
        GLib.set_application_name("BenchLab")
        self.args = args
        self.state = {"mode": args.mode, "seed": args.seed, "seq": 0}
        self.params = getattr(C, "derive_" + args.mode)(args.seed)
        self.fields = {}
        self.loading = False
        args.events.parent.mkdir(parents=True, exist_ok=True)
        self.events = args.events.open("w", buffering=1)
        self.window = Gtk.Window(title=f"BenchLab — {args.mode}")
        self.window.set_wmclass("BenchLab", "BenchLab")
        self.window.set_default_size(760, 540)
        self.window.connect("destroy", Gtk.main_quit)
        self.box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=12, margin=24)
        self.window.add(self.box)
        getattr(self, args.mode)()
        self.window.show_all()
        for widget in getattr(self, "hidden", []):
            widget.hide()
        self.emit("app_start", mode=args.mode, seed=args.seed)

    def emit(self, event: str, **details: object) -> None:
        self.state["seq"] += 1
        self.events.write(
            json.dumps(
                {
                    "seq": self.state["seq"],
                    "t": time.time() * 1000,
                    "type": event,
                    "details": details,
                }
            )
            + "\n"
        )
        self.args.state.parent.mkdir(parents=True, exist_ok=True)
        tmp = self.args.state.with_suffix(".tmp")
        tmp.write_text(json.dumps(self.state))
        os.replace(tmp, self.args.state)

    def label(self, text: str, box: Gtk.Box | None = None) -> Gtk.Label:
        label = Gtk.Label(label=text)
        (box or self.box).pack_start(label, False, False, 0)
        return label

    def button(self, text: str, callback, box: Gtk.Box | None = None) -> Gtk.Button:
        button = Gtk.Button(label=text)
        button.connect("clicked", lambda *_: callback())
        (box or self.box).pack_start(button, False, False, 0)
        return button

    def field(self, name: str, choices: list[str] | None = None, value: str = ""):
        self.label(name.capitalize())
        if choices:
            widget = Gtk.ComboBoxText()
            for item in choices:
                widget.append_text(item)
            widget.set_active(choices.index(value) if value in choices else 0)
        else:
            widget = Gtk.Entry()
            widget.set_text(value)
        widget.get_accessible().set_name(name.capitalize())
        self.fields[name] = widget
        widget.connect("changed", lambda *_: self.edit(name))
        self.box.pack_start(widget, False, False, 0)
        return widget

    def values(self) -> dict:
        return {
            key: widget.get_active_text()
            if isinstance(widget, Gtk.ComboBoxText)
            else widget.get_active()
            if isinstance(widget, Gtk.CheckButton)
            else widget.get_text()
            for key, widget in self.fields.items()
        }

    def edit(self, name: str) -> None:
        if self.loading:
            return
        values = self.values()
        self.state["fields"] = values
        if self.args.mode == "irunsaved":
            self.state["dirty"] = True
        self.emit("field_edit", field=name, value=values[name])
        if self.args.mode == "irbanner" and not self.state["banner_shown"]:
            self.state["banner_shown"] = True
            GLib.timeout_add(200, self.show_banner)
        if self.args.mode == "irconsent" and not self.state["consent_shown"]:
            self.state["consent_shown"] = True
            GLib.timeout_add(250, self.show_consent)

    def dialog(self, title: str, buttons: list[tuple[str, str]], callback) -> None:
        dialog = Gtk.Dialog(title=title, transient_for=self.window, modal=True)
        dialog.set_focus_on_map(False)
        dialog.get_content_area().add(Gtk.Label(label=title, margin=24))
        for index, (text, _) in enumerate(buttons):
            dialog.add_button(text, index)

        def response(widget, code):
            if not 0 <= code < len(buttons):
                return  # a window-manager close or other non-button response is not an answer
            widget.destroy()
            callback(buttons[code][1])

        dialog.connect("response", response)
        # Window-manager close is not an answer; keep the dialog until a button is used.
        dialog.connect("delete-event", lambda *_: True)
        dialog.show_all()

    def listdrag(self) -> None:
        self.state.update(
            order=list(self.params["initial"]),
            move_count=0,
            drag_begins=0,
            done=False,
            done_count=0,
        )
        self.label("Drag the rows to reorder them, then press Done")
        self.rows = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
        self.box.pack_start(self.rows, True, True, 0)
        self.drag_item = None
        self.draw_rows()
        self.button("Done", self.list_done)

    def draw_rows(self) -> None:
        for child in self.rows.get_children():
            child.destroy()
        targets = [Gtk.TargetEntry.new("text/plain", Gtk.TargetFlags.SAME_APP, 0)]
        for index, item in enumerate(self.state["order"]):
            row = Gtk.EventBox()
            row.add(Gtk.Label(label=item, margin=12))
            row.drag_source_set(
                Gdk.ModifierType.BUTTON1_MASK, targets, Gdk.DragAction.COPY | Gdk.DragAction.MOVE
            )
            row.drag_dest_set(
                Gtk.DestDefaults.ALL, targets, Gdk.DragAction.COPY | Gdk.DragAction.MOVE
            )
            row.connect("drag-begin", self.drag_begin, item)
            row.connect(
                "drag-data-get", lambda w, ctx, data, *_: data.set_text(self.drag_item or "", -1)
            )
            row.connect("drag-data-received", self.drop, index)
            self.rows.pack_start(row, True, True, 0)
        self.rows.show_all()

    def drag_begin(self, widget, context, item: str) -> None:
        self.drag_item = item
        self.state["drag_begins"] += 1
        self.emit("drag_begin", item=item)

    def drop(self, widget, context, x, y, data, info, timestamp, index: int) -> None:
        item = data.get_text()
        if item != self.drag_item or item not in self.state["order"]:
            Gtk.drag_finish(context, False, False, timestamp)
            return
        order = self.state["order"]
        source = order.index(item)
        order.pop(source)
        order.insert(index, item)
        self.state["move_count"] += 1
        self.emit("reorder", **{"from": source, "to": index, "item": item, "order": list(order)})
        Gtk.drag_finish(context, True, False, timestamp)
        self.drag_item = None
        GLib.idle_add(self.draw_rows)

    def list_done(self) -> None:
        self.state.update(
            done=True, done_count=self.state["done_count"] + 1, done_order=list(self.state["order"])
        )
        self.emit("done_click", order=self.state["done_order"])

    def hover(self) -> None:
        self.state.update(
            overlay_names=self.params["names"], clicks=[], hover_enter_count=0, hover_exit_count=0
        )
        zone = Gtk.EventBox()
        zone.add_events(Gdk.EventMask.ENTER_NOTIFY_MASK | Gdk.EventMask.LEAVE_NOTIFY_MASK)
        content = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
        zone.add(content)
        self.label("Hover here to reveal actions", content)
        actions = Gtk.Box(spacing=10)
        content.pack_start(actions, False, False, 0)
        for name in self.params["names"]:
            self.button(name, lambda n=name: self.hover_click(n), actions)
        self.hidden = [actions]
        self.visible = False

        def crossing(widget, event, entered):
            if event.detail == Gdk.NotifyType.INFERIOR:
                return False
            self.state["hover_enter_count" if entered else "hover_exit_count"] += 1
            self.emit(
                "mouse", region="hot_zone", phase="mouseEntered" if entered else "mouseExited"
            )
            self.visible = entered
            actions.set_visible(entered)
            if entered:
                self.emit("overlay_shown")
            return False

        zone.connect("enter-notify-event", crossing, True)
        zone.connect("leave-notify-event", crossing, False)
        self.box.pack_start(zone, True, True, 0)

    def hover_click(self, name: str) -> None:
        self.state["clicks"].append({"name": name})
        self.state.update(last_clicked=name, last_click_overlay_visible=self.visible)
        self.emit("overlay_click", name=name, overlay_visible=self.visible)

    def tooltip(self) -> None:
        self.state.update(submit_count=0, status="Ready")
        icons = Gtk.Box(spacing=24)
        self.box.pack_start(icons, True, True, 0)
        for index, icon in enumerate(self.params["order"]):
            widget = Gtk.Label(label=icon)
            widget.set_has_tooltip(True)
            widget.connect("query-tooltip", self.tooltip_query, icon, self.params["codes"][index])
            icons.pack_start(widget, True, True, 0)
        self.field("code")
        self.button("Submit", self.tooltip_submit)

    def tooltip_query(self, widget, x, y, keyboard, tooltip, icon, code) -> bool:
        if keyboard:
            return False
        tooltip.set_text(code)
        self.emit("tooltip_query", icon=icon)
        return True

    def tooltip_submit(self) -> None:
        value = self.values()["code"]
        self.state.update(
            submit_count=self.state["submit_count"] + 1, status="Submitted", submitted_value=value
        )
        self.emit("submit", value=value)

    def irmodal(self) -> None:
        self.state.update(
            prompt_answers=[], submit_count=0, page=1, prompt_state="not_shown", next_count=0
        )
        self.field("name")
        self.field("email")
        self.step1 = list(self.box.get_children())
        self.field("team", C.IR_TEAMS)
        self.field("seats")
        self.step2 = [widget for widget in self.box.get_children() if widget not in self.step1]
        self.hidden = self.step2
        self.submit_button = self.button("Next", self.permission)
        self.state["fields"] = self.values()

    def permission(self) -> None:
        self.state["next_count"] += 1
        self.emit("next", count=self.state["next_count"], values=self.values())
        self.state["prompt_state"] = "open"
        self.emit("permission_prompt_shown", resource=self.params["resource"])
        self.dialog(
            f"Allow BenchLab to access {self.params['resource']}?",
            [("Don’t Allow", "deny"), ("Allow", "allow")],
            self.permission_answer,
        )

    def permission_answer(self, answer: str) -> None:
        self.state["prompt_answers"].append(answer)
        self.state.update(page=2, prompt_state="denied" if answer == "deny" else "allowed")
        self.emit("permission_answer", answer=answer, resource=self.params["resource"])
        for widget in self.step1:
            widget.hide()
        for widget in self.step2:
            widget.show_all()
        self.submit_button.destroy()
        self.button("Submit", self.form_submit).show()

    def form_submit(self) -> None:
        values = self.values()
        self.state.update(submit_count=self.state["submit_count"] + 1, submitted=values)
        self.emit("submit", values=values)

    def irbanner(self) -> None:
        self.state.update(
            banner_shown=False, banner_actions=[], banner_body_clicks=0, apply_count=0
        )
        self.label(self.params["item"])
        self.field("quantity", value="1")
        self.field("priority", C.PRIORITIES)
        self.apply_button = self.button("Apply", self.apply)
        self.box.remove(self.apply_button)
        overlay = Gtk.Overlay()
        overlay.add(self.apply_button)
        self.banner = Gtk.EventBox()
        content = Gtk.Box(spacing=8)
        self.banner.add(content)
        self.label("Update available", content)
        for label, action in (
            ("Restart Now", "restart"),
            ("Later", "later"),
            ("Dismiss", "dismiss"),
        ):
            self.button(label, lambda a=action: self.banner_action(a), content)
        self.banner.connect("button-press-event", self.banner_body_click)
        overlay.add_overlay(self.banner)
        self.box.pack_end(overlay, False, False, 0)
        self.hidden = [self.banner]
        self.state["fields"] = self.values()

    def banner_body_click(self, *_: object) -> bool:
        self.state["banner_body_clicks"] += 1
        self.emit("banner_body_click", count=self.state["banner_body_clicks"])
        return False

    def show_banner(self) -> bool:
        self.banner.show_all()
        self.emit("banner_shown")
        return False

    def banner_action(self, action: str) -> None:
        self.state["banner_actions"].append(action)
        if action == "restart":
            self.fields["quantity"].set_text("1")
            self.fields["priority"].set_active(0)
        self.banner.hide()
        self.emit("banner_action", action=action)

    def apply(self) -> None:
        self.state["apply_count"] += 1
        self.emit("apply", values=self.values())

    def irunsaved(self) -> None:
        self.state.update(
            saved=[
                {
                    "title": title,
                    "status": C.IR_INITIAL_STATUS,
                    "body": f"Working notes for {title}.",
                }
                for title in self.params["titles"]
            ],
            dirty=False,
            answers=[],
            done_count=0,
        )
        self.selected = 0
        for index, title in enumerate(self.params["titles"]):
            self.button(title, lambda i=index: self.navigate(i))
        self.field("title", value=self.state["saved"][0]["title"])
        self.field("status", [C.IR_INITIAL_STATUS, *C.IR_STATUS_WORDS])
        self.field("body", value=self.state["saved"][0]["body"])
        self.button("Done", lambda: self.navigate(None))

    def navigate(self, index: int | None) -> None:
        if self.state["dirty"]:
            self.emit("save_prompt_shown")
            self.dialog(
                "Save changes before leaving?",
                [("Save", "save"), ("Don’t Save", "dont_save"), ("Cancel", "cancel")],
                lambda answer: self.save_answer(answer, index),
            )
        else:
            self.visit(index)

    def save_answer(self, answer: str, index: int | None) -> None:
        self.state["answers"].append(answer)
        self.emit("save_answer", answer=answer)
        if answer == "cancel":
            return
        if answer == "save":
            self.state["saved"][self.selected] = self.values()
            self.emit("save", index=self.selected, values=self.values())
        else:
            self.emit("discard", index=self.selected)
        self.state["dirty"] = False
        self.visit(index)

    def visit(self, index: int | None) -> None:
        if index is None:
            self.state["done_count"] += 1
            self.emit("done", clean=not self.state["dirty"])
        else:
            self.selected = index
        self.loading = True
        for key, value in self.state["saved"][self.selected].items():
            widget = self.fields[key]
            if isinstance(widget, Gtk.ComboBoxText):
                widget.set_active([C.IR_INITIAL_STATUS, *C.IR_STATUS_WORDS].index(value))
            else:
                widget.set_text(value)
        self.loading = False
        if index is not None:
            self.emit("note_selected", index=index)

    def irconsent(self) -> None:
        self.state.update(
            consent_shown=False, consent_answers=[], submit_count=0, submits_blocked=0
        )
        self.field("email")
        self.field("plan", C.IR_PLANS)
        digest = Gtk.CheckButton(label="Email digest")
        self.fields["digest"] = digest
        digest.connect("toggled", lambda *_: self.edit("digest"))
        self.box.pack_start(digest, False, False, 0)
        self.button("Sign up", self.signup)

    def show_consent(self) -> bool:
        self.emit("consent_shown")
        self.dialog(
            "Cookie preferences",
            [("Reject optional", "reject"), ("Accept all", "accept")],
            self.consent_answer,
        )
        return False

    def consent_answer(self, answer: str) -> None:
        details = {"answer": answer, "analytics": answer == "accept", "ads": answer == "accept"}
        self.state["consent_answers"].append(details)
        self.emit("consent_answer", **details)

    def signup(self) -> None:
        if not self.state["consent_answers"]:
            self.state["submits_blocked"] += 1
            self.emit("submit_blocked")
            return
        self.state["submit_count"] += 1
        self.emit("submit", **self.values())


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--mode", choices=MODES, required=True)
    parser.add_argument("--seed", type=int, required=True)
    parser.add_argument("--state", type=Path, required=True)
    parser.add_argument("--events", type=Path, required=True)
    lab = Lab(parser.parse_args())
    try:
        Gtk.main()
    finally:
        lab.events.close()


if __name__ == "__main__":
    main()