mobster-cli 0.4.3__py3-none-any.whl

mobile_agent/swift/helper_transfer.swift

@@ -0,0 +1,246 @@
+// transfer: hands files from this Mac to an iPhone without a cable, for mobile_agent/phone_io/handoff.py.
+//
+//   transfer airdrop --to NAME [--timeout S] FILE...
+//       AirDrop's own panel (NSSharingService), and a press on the one recipient whose name is exactly NAME. Another
+//       name, two devices with that name, or none in time: Cancel is pressed and nothing is sent.
+//       {"ok":true,"sent":N,"seconds":S} | {"ok":false,"code":"not_found"|"ambiguous","seen":[names]}
+//   transfer drop --x FX --y FY FILE...
+//       Drags the files from a 32-point spot of this helper's onto the iPhone Mirroring window, at a point given as
+//       fractions of the window, as a person drags from Finder. iPhone Mirroring hands them to the app in front on
+//       the phone. {"ok":true,"operation":N} once the window took them.
+//
+// One JSON line on standard output. Errors: {"ok":false,"code","error"}: "usage", "permission" (Accessibility is
+// missing), "no_window" (iPhone Mirroring isn't showing the phone), "refused" (the window didn't take the drop),
+// "failed" (AirDrop said it failed or the person on the phone declined), "timeout". Nothing is retried here.
+//
+// The Mac app carries it as Contents/Resources/transfer; a source checkout builds it with
+// native_helpers.build("transfer").
+
+import AppKit
+import ApplicationServices
+import CoreGraphics
+import Foundation
+
+let mirroringBundle = "com.apple.ScreenContinuity"
+
+func emit(_ value: [String: Any]) -> Never {
+    let data = (try? JSONSerialization.data(withJSONObject: value, options: [.sortedKeys])) ?? Data("{}".utf8)
+    FileHandle.standardOutput.write(data)
+    FileHandle.standardOutput.write(Data("\n".utf8))
+    exit(value["ok"] as? Bool == true ? 0 : 1)
+}
+
+func fail(_ code: String, _ message: String, _ extra: [String: Any] = [:]) -> Never {
+    var out: [String: Any] = ["ok": false, "code": code, "error": message]
+    for (key, value) in extra { out[key] = value }
+    emit(out)
+}
+
+// MARK: - arguments
+
+var arguments = Array(CommandLine.arguments.dropFirst())
+guard let op = arguments.first, ["airdrop", "drop"].contains(op) else {
+    fail("usage", "transfer airdrop --to NAME FILE... | transfer drop --x FX --y FY FILE...")
+}
+arguments.removeFirst()
+var options: [String: String] = [:]
+var paths: [String] = []
+var index = 0
+while index < arguments.count {
+    let word = arguments[index]
+    if word.hasPrefix("--"), index + 1 < arguments.count {
+        options[String(word.dropFirst(2))] = arguments[index + 1]
+        index += 2
+    } else {
+        paths.append(word)
+        index += 1
+    }
+}
+let files = paths.map { URL(fileURLWithPath: $0) }
+if files.isEmpty || files.contains(where: { !FileManager.default.isReadableFile(atPath: $0.path) }) {
+    fail("usage", "Name files that exist and can be read")
+}
+if !AXIsProcessTrusted() {
+    fail("permission", "Mobster needs Accessibility to do this. Turn it on in System Settings › Privacy & Security › Accessibility.")
+}
+
+let app = NSApplication.shared
+app.setActivationPolicy(.accessory)
+
+// MARK: - AirDrop
+
+func attribute(_ element: AXUIElement, _ name: String) -> AnyObject? {
+    var value: AnyObject?
+    return AXUIElementCopyAttributeValue(element, name as CFString, &value) == .success ? value : nil
+}
+
+/// The AirDrop panel's recipients ("dd.nodeBody" buttons, named by their description) and its Cancel button.
+func panel() -> (recipients: [(name: String, element: AXUIElement)], cancel: AXUIElement?) {
+    var recipients: [(String, AXUIElement)] = []
+    var cancel: AXUIElement?
+    func walk(_ node: AXUIElement, _ depth: Int) {
+        if depth > 16 { return }
+        let role = attribute(node, kAXRoleAttribute) as? String ?? ""
+        let name = attribute(node, kAXDescriptionAttribute) as? String ?? ""
+        let identifier = attribute(node, kAXIdentifierAttribute) as? String ?? ""
+        if role == kAXButtonRole {
+            if identifier == "dd.nodeBody", !name.isEmpty { recipients.append((name, node)) }
+            if identifier.isEmpty, name == "Cancel" { cancel = node }
+        }
+        for child in (attribute(node, kAXChildrenAttribute) as? [AXUIElement]) ?? [] { walk(child, depth + 1) }
+    }
+    walk(AXUIElementCreateApplication(getpid()), 0)
+    return (recipients, cancel)
+}
+
+final class Sharing: NSObject, NSSharingServiceDelegate {
+    let started = Date()
+    func sharingService(_ sharingService: NSSharingService, didShareItems items: [Any]) {
+        emit(["ok": true, "sent": items.count, "seconds": (Date().timeIntervalSince(started) * 10).rounded() / 10])
+    }
+    func sharingService(_ sharingService: NSSharingService, didFailToShareItems items: [Any], error: Error) {
+        let cancelled = (error as NSError).code == NSUserCancelledError
+        fail(cancelled ? "cancelled" : "failed", cancelled ? "The AirDrop was cancelled" : error.localizedDescription)
+    }
+}
+
+func airdrop() {
+    guard let recipient = options["to"], !recipient.isEmpty else { fail("usage", "Name the iPhone with --to") }
+    let waitForRecipient = Double(options["timeout"] ?? "30") ?? 30
+    let waitForTransfer = Double(options["transfer-timeout"] ?? "900") ?? 900
+    guard let service = NSSharingService(named: .sendViaAirDrop), service.canPerform(withItems: files) else {
+        fail("failed", "AirDrop isn't available on this Mac. Turn on Wi-Fi and Bluetooth.")
+    }
+    let delegate = Sharing()
+    service.delegate = delegate
+    service.perform(withItems: files)
+    var pressed = false
+    var seen: Set<String> = []
+    let opened = Date()
+    Timer.scheduledTimer(withTimeInterval: 0.5, repeats: true) { timer in
+        let (recipients, cancel) = panel()
+        seen.formUnion(recipients.map(\.name))
+        let matching = recipients.filter { $0.name == recipient }
+        if !pressed && matching.count > 1 {
+            if let cancel { AXUIElementPerformAction(cancel, kAXPressAction as CFString) }
+            fail("ambiguous", "More than one device nearby is called \(recipient)", ["seen": Array(seen).sorted()])
+        }
+        if !pressed, let only = matching.first {
+            // Wait one more beat: a second device with the same name can show up a moment later.
+            if Date().timeIntervalSince(opened) < 2.5 { return }
+            pressed = AXUIElementPerformAction(only.element, kAXPressAction as CFString) == .success
+            if !pressed { fail("failed", "AirDrop didn't take the press on \(recipient)") }
+            timer.invalidate()
+            DispatchQueue.main.asyncAfter(deadline: .now() + waitForTransfer) {
+                fail("timeout", "AirDrop didn't finish within \(Int(waitForTransfer)) seconds")
+            }
+            return
+        }
+        if Date().timeIntervalSince(opened) > waitForRecipient {
+            if let cancel { AXUIElementPerformAction(cancel, kAXPressAction as CFString) }
+            fail("not_found", "AirDrop didn't show \(recipient) within \(Int(waitForRecipient)) seconds",
+                 ["seen": Array(seen).sorted()])
+        }
+    }
+}
+
+// MARK: - a drop on iPhone Mirroring
+
+func post(_ type: CGEventType, _ point: CGPoint) {
+    CGEvent(mouseEventSource: nil, mouseType: type, mouseCursorPosition: point, mouseButton: .left)?.post(tap: .cghidEventTap)
+}
+
+final class DragSource: NSView, NSDraggingSource {
+    var finished: ((NSDragOperation) -> Void)?
+    func draggingSession(_ session: NSDraggingSession, sourceOperationMaskFor context: NSDraggingContext) -> NSDragOperation {
+        .copy
+    }
+    override func acceptsFirstMouse(for event: NSEvent?) -> Bool { true }
+    override func mouseDown(with event: NSEvent) {
+        let items = files.map { url -> NSDraggingItem in
+            let item = NSDraggingItem(pasteboardWriter: url as NSURL)
+            item.setDraggingFrame(bounds, contents: NSWorkspace.shared.icon(forFile: url.path))
+            return item
+        }
+        beginDraggingSession(with: items, event: event, source: self)
+    }
+    func draggingSession(_ session: NSDraggingSession, endedAt screenPoint: NSPoint, operation: NSDragOperation) {
+        finished?(operation)
+    }
+}
+
+func mirroringWindow() -> (app: NSRunningApplication, frame: CGRect)? {
+    guard let running = NSRunningApplication.runningApplications(withBundleIdentifier: mirroringBundle).first else {
+        return nil
+    }
+    let windows = (CGWindowListCopyWindowInfo([.optionOnScreenOnly, .excludeDesktopElements], kCGNullWindowID)
+        as? [[String: Any]]) ?? []
+    for window in windows where (window[kCGWindowOwnerPID as String] as? pid_t) == running.processIdentifier
+        && (window[kCGWindowLayer as String] as? Int) == 0 {
+        guard let bounds = window[kCGWindowBounds as String] as? [String: Double] else { continue }
+        let frame = CGRect(x: bounds["X"] ?? 0, y: bounds["Y"] ?? 0, width: bounds["Width"] ?? 0,
+                           height: bounds["Height"] ?? 0)
+        if frame.width > 150, frame.height > 300 { return (running, frame) }
+    }
+    return nil
+}
+
+func drop() {
+    guard let fx = Double(options["x"] ?? ""), let fy = Double(options["y"] ?? ""), (0...1).contains(fx),
+          (0...1).contains(fy) else {
+        fail("usage", "--x and --y are fractions of the window, 0 to 1")
+    }
+    guard let (mirroring, frame) = mirroringWindow() else {
+        fail("no_window", "iPhone Mirroring isn't showing the phone")
+    }
+    let front = NSWorkspace.shared.frontmostApplication
+    mirroring.activate()
+    let target = CGPoint(x: frame.minX + frame.width * fx, y: frame.minY + frame.height * fy)
+    // The drag starts beside the window (left of it, or right when it sits at the screen's left edge).
+    let screen = NSScreen.screens.first?.frame ?? CGRect(x: 0, y: 0, width: 1440, height: 900)
+    let startX = frame.minX > 80 ? frame.minX - 48 : min(frame.maxX + 48, screen.width - 24)
+    let start = CGPoint(x: startX, y: target.y)
+    let window = NSWindow(contentRect: NSRect(x: start.x - 16, y: screen.height - start.y - 16, width: 32, height: 32),
+                          styleMask: .borderless, backing: .buffered, defer: false)
+    window.level = .screenSaver
+    window.isOpaque = false
+    window.backgroundColor = NSColor.white.withAlphaComponent(0.02)
+    let source = DragSource(frame: NSRect(x: 0, y: 0, width: 32, height: 32))
+    window.contentView = source
+    window.orderFrontRegardless()
+    let saved = CGEvent(source: nil)?.location
+    func finish(_ value: [String: Any]) -> Never {
+        if let saved { CGWarpMouseCursorPosition(saved) }
+        if let front, front.bundleIdentifier != mirroringBundle { front.activate() }
+        emit(value)
+    }
+    source.finished = { operation in
+        if operation.isEmpty {
+            finish(["ok": false, "code": "refused", "error": "iPhone Mirroring didn't take the files"])
+        }
+        finish(["ok": true, "operation": Int(operation.rawValue)])
+    }
+    DispatchQueue.global().asyncAfter(deadline: .now() + 0.4) {
+        post(.mouseMoved, start)
+        usleep(60_000)
+        post(.leftMouseDown, start)
+        usleep(120_000)
+        for step in 1...30 {
+            let t = Double(step) / 30
+            post(.leftMouseDragged, CGPoint(x: start.x + (target.x - start.x) * t, y: start.y + (target.y - start.y) * t))
+            usleep(20_000)
+        }
+        // Held over the window a moment so it can say it takes them, then let go.
+        for _ in 0..<12 {
+            post(.leftMouseDragged, target)
+            usleep(50_000)
+        }
+        post(.leftMouseUp, target)
+    }
+    DispatchQueue.main.asyncAfter(deadline: .now() + 15) {
+        finish(["ok": false, "code": "timeout", "error": "The drag didn't finish"])
+    }
+}
+
+DispatchQueue.main.async { op == "airdrop" ? airdrop() : drop() }
+app.run()

mobile_agent/swift/ocr.swift

@@ -0,0 +1,22 @@
+import Foundation
+import Vision
+
+// Reads one image on stdin. Output rects use normalized, top-left coordinates.
+do {
+    let data = FileHandle.standardInput.readDataToEndOfFile()
+    let request = VNRecognizeTextRequest()
+    request.recognitionLevel = .fast
+    request.usesLanguageCorrection = false
+    let handler = VNImageRequestHandler(data: data, options: [:])
+    try handler.perform([request])
+    let rows: [[String: Any]] = (request.results ?? []).compactMap { observation in
+        guard let candidate = observation.topCandidates(1).first else { return nil }
+        let box = observation.boundingBox
+        return ["text": candidate.string, "confidence": candidate.confidence,
+                "rect": [box.minX, 1 - box.maxY, box.width, box.height]]
+    }
+    FileHandle.standardOutput.write(try JSONSerialization.data(withJSONObject: rows))
+} catch {
+    FileHandle.standardError.write(Data("OCR failed\n".utf8))
+    exit(1)
+}

mobile_agent/task_policy.py

@@ -0,0 +1,337 @@
+"""Typed user-policy questions; inferred output never grants action authority."""
+
+import re
+from dataclasses import replace
+from enum import StrEnum
+
+
+class RiskTier(StrEnum):
+    """Named dispatch risk for confidence-gated actions."""
+    SCROLL = "scroll"
+    NAVIGATION = "navigation"
+    TYPE = "type"
+    SIDE_EFFECT = "side_effect"
+
+
+# AUTHORITY_RULES spirit: send/post/buy/follow/like are never implicit.
+SIDE_EFFECT_REQUEST = re.compile(
+    r"\b(send|post|like|follow|buy|purchase|order|pay|submit|publish|comment|share|"
+    r"delete|remove|confirm|checkout|transfer|message|email|install|upload|redeem|"
+    r"book|reserve|donate|tip|subscribe|set|save|create|update|apply|"
+    r"sign[ -]?up|log[ -]?in)\b",
+    re.I)
+
+SIDE_EFFECT_CONTROL = re.compile(
+    r"\b(send|post|like|follow|buy|purchase|order|pay|submit|save|publish|comment|"
+    r"share|delete|remove|confirm|checkout|done|transfer|donate|tip|subscribe|"
+    r"accept|approve|install|upload|redeem|book|reserve|create|sign[ -]?up|log[ -]?in)\b",
+    re.I)
+
+
+# Roles whose tap only moves between screens.
+NAVIGATION_TAP_ROLES = frozenset({"Button", "Cell", "Link", "StaticText", "Image", "Icon", "Other"})
+# Verbs that make even a plain button state-changing; any match keeps the verifier.
+STATE_CHANGING_LABEL = re.compile(
+    r"\b(erase|reset|turn\s+(on|off)|enable|disable|sign\s*(in|out|up)|log\s*(in|out)|restart|"
+    r"shut\s*down|power|clear|delete|remove|allow|deny|block|unblock|forget|disconnect|connect|"
+    r"pair|unpair|update|install|download|upgrade|agree|accept|decline|join|leave|end|stop|start|"
+    r"call|dial|emergency|sos|pay|buy|purchase|send|share|trust|approve|confirm|submit|save|"
+    r"done|add|create|new|edit|change|set|reply|post|follow|like|subscribe|unsubscribe|report|"
+    r"archive|mute|unmute|hide|lock|unlock|restore|backup|sync|transfer|verify)\b",
+    re.I)
+
+
+# Keys of an on-screen keypad (Calculator, a PIN or dial pad): each press is input, not an effect to de-duplicate.
+KEYPAD_KEY = re.compile(r"^(\d|[+\-×x*÷/=.%,]|plus|minus|add|subtract|multiply|times|divide|equals|decimal|point|"
+                        r"percent|clear|all clear|delete|backspace|negate|change sign|"
+                        r"zero|one|two|three|four|five|six|seven|eight|nine)$", re.I)
+
+
+def is_keypad_key(operation, role, label):
+    return operation == "TAP" and role in ("Key", "Button") and bool(KEYPAD_KEY.match((label or "").strip()))
+
+
+# SpringBoard's passcode keypad: lockscreen.py handles the lock screen, and every model tap there is refused.
+SPRINGBOARD_BUNDLE = "com.apple.springboard"
+_DIGIT_KEY = re.compile(r"^\s*(\d)(?!\d)")
+_PASSCODE_MARKER = re.compile(r"\b(enter passcode|passcode|emergency|touch id|face id)\b", re.I)
+
+
+def springboard_keypad(snapshot):
+    """True when ``snapshot`` is SpringBoard showing a digit keypad. Errs toward True: it only refuses."""
+    if getattr(snapshot, "bundle_id", "") != SPRINGBOARD_BUNDLE:
+        return False
+    digits, marked = set(), False
+    for element in getattr(snapshot, "elements", ()) or ():
+        label = element.label or ""
+        found = _DIGIT_KEY.match(label)
+        if found and element.role in ("Button", "Key", "Other") and len(label) <= 12:
+            digits.add(found.group(1))
+        elif _PASSCODE_MARKER.search(label):
+            marked = True
+    return len(digits) >= 10 or len(digits) >= 6 and marked
+
+
+# Controls whose tap commits something the user would want to see first: money, messages, publishing and deletion.
+COMMIT_CONTROL_WORDS = (
+    "send", "post", "publish", "reply", "comment", "share", "tweet", "buy", "purchase", "order", "pay", "checkout",
+    "place order", "transfer", "donate", "tip", "subscribe", "book", "reserve", "delete", "erase", "remove", "reset",
+    "install", "upload", "redeem", "call", "dial", "facetime", "follow", "sign[ -]?up", "submit", "confirm")
+COMMIT_CONTROL = re.compile(r"\b(" + "|".join(COMMIT_CONTROL_WORDS) + r")\b", re.I)
+# Leading words of a label that can name a commit.
+GUARD_WORDS = 4
+# Controls that only open a sheet of choices (whose committing choice is guarded itself).
+SHEET_OPENERS = frozenset({"share", "share…", "share..."})
+
+
+APPROVAL_OPERATIONS = frozenset({"TAP", "SUBMIT", "TYPE_SUBMIT"})
+
+# Commits beyond COMMIT_CONTROL's words, for "ask before acting" only; a lookahead spares a control that opens.
+APPROVAL_COMMIT = re.compile(
+    r"\b(?:request(?!\s+(?:desktop|mobile)\b)|(?:move\s+to\s+)?trash|"
+    r"clear(?!\s+(?:text|search|query|field|filters?|selection)\b)|accept|decline|join|leave|"
+    r"block|report|unsubscribe|unfollow|unmatch|archive|mark\s+as\s+(?:junk|spam)|rent|"
+    r"cancel\s+(?:ride|trip|order|subscription|booking|reservation|membership|plan|appointment|delivery)|"
+    r"end\s+(?:call|trip|ride)|hang\s+up)\b"
+    r"|^\s*get\b(?!\s+(?:started|directions|help|info|more|support|details|tickets|the\s+app)\b)",
+    re.I)
+# The approval card's act for each of those words ("request", "trash"...).
+APPROVAL_ACT_ALIASES = {"move to trash": "trash", "mark as junk": "junk", "mark as spam": "junk", "hang up": "end call"}
+
+
+# Roles whose label is what they show, not what a tap on them does.
+CONTENT_ROLES = frozenset({"Cell", "StaticText", "TextField", "TextView", "SecureTextField", "SearchField", "Image",
+                           "Icon"})
+# A tap on a field only focuses it, whatever its label ("Order more coffee filters", "Comment").
+EDITABLE_ROLES = frozenset({"TextField", "TextView", "SecureTextField", "SearchField"})
+# The state iOS appends to a reminder's row ("Buy oat milk, Incomplete"): that label is always content.
+ROW_STATE = re.compile(r",\s*(?:Incomplete|Completed)$", re.I)
+# Acts a row names as often as a control ("Call the dentist"): in content, only in labels of CONTROL_WORDS words.
+TALK_ACTS = frozenset({"call", "dial", "facetime", "reply", "comment", "follow"})
+CONTROL_WORDS = 2
+# The checkout button's own words, which COMMIT_CONTROL's "place order" does not read.
+PLACE_ORDER = re.compile(r"^place\s+(?:(?:your|the|this|my)\s+)?order\b", re.I)
+
+
+# Bare labels that only open a composer or a sheet (a tap on them sends nothing).
+TAP_OPENERS = frozenset({"share", "share…", "share...", "comment", "comments", "reply"})
+UNSEND = re.compile(r"\b(?:unsend|undo send)\b", re.I)
+
+
+def commit_label(label, role=None):
+    """The commit a control's label names, or None; a spurious ask on a plain row is the safe failure."""
+    label = " ".join((label or "").split())
+    if ROW_STATE.search(label):
+        return None
+    folded = label.casefold()
+    if role is not None and folded in TAP_OPENERS:
+        return None  # it opens a composer or a sheet, whose own Send or Post asks
+    unsend = UNSEND.search(label)
+    if unsend and role not in EDITABLE_ROLES:
+        return unsend.group(0)
+    match = COMMIT_CONTROL.search(label) or APPROVAL_COMMIT.search(label)
+    if role not in CONTENT_ROLES:
+        return match.group(0) if match else None
+    if role in EDITABLE_ROLES or "," in label:
+        return None
+    first = PLACE_ORDER.match(label) or COMMIT_CONTROL.match(label) or APPROVAL_COMMIT.match(label)
+    if first is None or _act(first.group(0)) in TALK_ACTS and len(label.split()) > CONTROL_WORDS:
+        return None
+    return first.group(0)
+
+
+# Roles that hold other elements rather than act on a tap: panes, bars, sheets. Text inside one is not its label.
+CONTAINER_ROLES = frozenset({"Application", "Window", "ScrollView", "Table", "CollectionView", "WebView", "Group",
+                             "NavigationBar", "TabBar", "Toolbar", "StatusBar", "Keyboard", "Alert", "Sheet",
+                             "Menu", "MenuBar"})
+
+
+def _holds(outer, point):
+    x, y, w, h = outer.rect
+    return x - 1e-6 <= point[0] <= x + w + 1e-6 and y - 1e-6 <= point[1] <= y + h + 1e-6
+
+
+def same_words(a, b):
+    return " ".join((a or "").split()).casefold() == " ".join((b or "").split()).casefold()
+
+
+def approval_subject(elements, target):
+    """The element "ask before acting" reads for a tap on ``target``; a commit is never read away."""
+    if target is None or target.role not in CONTENT_ROLES or target.role in EDITABLE_ROLES:
+        return target
+    point = target.tap_point
+    around = [e for e in elements if e is not target and e.id != target.id and _holds(e, point)]
+    area = lambda e: e.rect[2] * e.rect[3]
+    controls = sorted((e for e in around if e.role not in CONTENT_ROLES and e.role not in CONTAINER_ROLES),
+                      key=lambda e: (not same_words(e.label, target.label), area(e)))
+    if controls:
+        control = controls[0]
+        if not control.label.strip():
+            # An unlabelled button is named by the text on it.
+            return replace(control, label=target.label)
+        if commit_label(control.label, control.role) or not commit_label(target.label, target.role):
+            return control
+        return target
+    rows = sorted((e for e in around if e.role == "Cell"), key=area)
+    if rows and ("," in rows[0].label or ROW_STATE.search(" ".join(rows[0].label.split()))):
+        return rows[0]
+    return target
+
+
+def label_role(operation, role):
+    """The role ``commit_label`` reads a target's label with: its own for a tap, none for a submit."""
+    return role if operation == "TAP" else None
+
+
+def approval_kind(operation, label, *, risk_tier, uncertain=False, role=None):
+    """What "ask before acting" asks: "commit", "unsure" or None; scrolling and typing without Return never commit."""
+    if operation in APPROVAL_OPERATIONS and (
+            commit_label(label, label_role(operation, role))
+            or operation in {"SUBMIT", "TYPE_SUBMIT"} and risk_tier == RiskTier.SIDE_EFFECT.value):
+        return "commit"
+    return "unsure" if uncertain else None
+
+
+# The act a commit approval names, from the control's label or else the request, and its title.
+APPROVAL_TITLES = {
+    "send": "Send this message?", "reply": "Send this reply?", "comment": "Post this comment?",
+    "post": "Post this?", "publish": "Publish this?", "tweet": "Post this?", "share": "Share this?",
+    "buy": "Buy this?", "purchase": "Buy this?", "order": "Place this order?", "place order": "Place this order?",
+    "checkout": "Check out?", "pay": "Make this payment?", "transfer": "Make this transfer?",
+    "donate": "Make this donation?", "tip": "Leave this tip?", "subscribe": "Subscribe?",
+    "book": "Make this booking?", "reserve": "Make this reservation?", "delete": "Delete this?",
+    "erase": "Erase this?", "remove": "Remove this?", "reset": "Reset this?", "install": "Install this?",
+    "upload": "Upload this?", "redeem": "Redeem this?", "call": "Place this call?", "dial": "Place this call?",
+    "facetime": "Start this FaceTime call?", "follow": "Follow this account?", "sign up": "Sign up?",
+    "submit": "Submit this?", "confirm": "Confirm this?",
+    "request": "Send this request?", "trash": "Move this to the trash?", "clear": "Clear these?",
+    "accept": "Accept this?", "decline": "Decline this?", "join": "Join this?", "leave": "Leave this?",
+    "block": "Block this contact?", "report": "Report this?", "unsubscribe": "Unsubscribe?",
+    "unfollow": "Unfollow this account?", "unmatch": "Unmatch?", "archive": "Archive this?",
+    "junk": "Mark this as junk?", "rent": "Rent this?", "get": "Get this app?", "end call": "End this call?",
+    "react": "Send this reaction?", "unsend": "Unsend this message?",
+}
+MESSAGE_ACTS = frozenset({"send", "reply", "comment", "post", "publish", "tweet", "share"})
+# Acts whose card names who it goes to ("Send this message to Sam?").
+RECIPIENT_TITLES = {"send": "Send this message to {}?", "reply": "Send this reply to {}?"}
+
+
+def _act(match):
+    act = re.sub(r"[\s-]+", " ", match.casefold()).strip()
+    if PLACE_ORDER.match(act):
+        return "place order"
+    if act.replace(" ", "") == "signup":
+        return "sign up"
+    if act in ("unsend", "undo send"):
+        return "unsend"
+    if act.startswith("cancel ") or act.startswith("end "):
+        return "end call" if act == "end call" else act
+    return APPROVAL_ACT_ALIASES.get(act, act)
+
+
+def commit_act(label, request="", role=None, operation="TAP"):
+    """The commit a control performs, as one lowercase verb ("send", "place order"), or "submit"."""
+    named = commit_label(label, label_role(operation, role))
+    if named:
+        return _act(named)
+    match = COMMIT_CONTROL.search(asked_part(request))
+    return _act(match.group(0)) if match else "submit"
+
+
+def approval_title(act, *, unsure=False, recipient=None):
+    """The approval card's title: the act as a question ("Send this message to Sam?")."""
+    if unsure:
+        return "Not sure about this step"
+    if recipient and act in RECIPIENT_TITLES:
+        return RECIPIENT_TITLES[act].format(recipient)
+    if act and act.startswith("cancel "):
+        return f"Cancel this {act.split(' ', 1)[1]}?"
+    return APPROVAL_TITLES.get(act, "Do this now?")
+
+
+def action_risk_tier(operation, target_label="", goal=""):
+    """Risk tier for one action. Side-effect parse follows the AUTHORITY_RULES spirit."""
+    if operation == "TYPE_SUBMIT":
+        # Typing plus Return: a search or address stays TYPE-tier; a send is a side effect.
+        if SIDE_EFFECT_CONTROL.search(target_label or "") or SIDE_EFFECT_REQUEST.search(goal or ""):
+            return RiskTier.SIDE_EFFECT
+        return RiskTier.TYPE
+    if operation in {"TYPE", "INCREMENT", "DECREMENT"}:
+        return RiskTier.TYPE
+    if operation in {"SWIPE_UP", "SWIPE_DOWN"}:
+        return RiskTier.SCROLL
+    # Horizontal swipes can page media or reveal row actions, so they stay navigation.
+    if operation in {"SWIPE_LEFT", "SWIPE_RIGHT", "BACK", "HOME",
+                       "VOLUME_UP", "VOLUME_DOWN", "LAUNCH_APP"}:
+        return RiskTier.NAVIGATION
+    if SIDE_EFFECT_CONTROL.search(target_label or "") or SIDE_EFFECT_REQUEST.search(goal or ""):
+        return RiskTier.SIDE_EFFECT
+    return RiskTier.NAVIGATION
+
+
+# The verifier's UNCLEAR ends a run; the request's own words are evidence that the act it names is the right one.
+PROHIBITION_SENTENCE = re.compile(r"[^.!?]*\b(?:do not|don't|never|without|only look)\b[^.!?]*(?:[.!?]|$)", re.I)
+CHANGE_REQUEST = re.compile(
+    r"\b(add|log|create|write|compose|draft|send|reply|message|share|post|book|reserve|order|buy|purchase|"
+    r"pay|transfer|set|schedule|change|update|edit|rename|move|archive|delete|remove|mark|flag|star|save|"
+    r"favorite|like|follow|connect|invite|accept|decline|join|upload|enable|disable|turn on|turn off|apply)\b",
+    re.I)
+_TEXT_ASKED = re.compile(r"\b(write|type|enter|message|reply|note|comment|compose|add|search|rename|label|name|"
+                         r"title|caption|describe|log|fill|draft|email|text)\b", re.I)
+
+
+def asked_part(request):
+    """The request without its prohibitions ("Do not delete anything" asks for no deletion)."""
+    return PROHIBITION_SENTENCE.sub(" ", request or "")
+
+
+def asks_for_changes(request):
+    return bool(CHANGE_REQUEST.search(asked_part(request)))
+
+
+def _inflections(word):
+    word = word.casefold()
+    stem = word[:-1] if word.endswith("e") else word
+    return {word, word + "s", word + "d", word + "ed", stem + "ing", stem + "ed", word + "ment", stem + "ion"}
+
+
+# Acts that are the same request in other words.
+ACT_SYNONYMS = (
+    {"order", "checkout", "purchase", "buy", "pay", "place"},
+    {"book", "reserve", "reservation", "confirm"},
+    {"send", "message", "post", "reply", "share"},
+    {"request", "split", "charge"},
+    {"add", "create", "new", "save", "log"},
+    {"archive", "file"},
+    {"delete", "remove", "trash"},
+)
+
+
+def synonyms(act):
+    """Every form of the other words for the same act (see ACT_SYNONYMS)."""
+    out = set()
+    for group in ACT_SYNONYMS:
+        if act in group or act.rstrip("s") in group:
+            for word in group:
+                out |= _inflections(word)
+    return out
+
+
+def requested_by(request, operation, role, label):
+    """Whether this action is one the request's own words ask for (never for a look-only request)."""
+    if not asks_for_changes(request):
+        return False
+    asked = asked_part(request).casefold()
+    words = set(re.findall(r"[a-z]+", asked))
+    if operation in {"TYPE", "TYPE_SUBMIT", "SUBMIT"} and role == "SearchField":
+        return True
+    if operation in {"TYPE", "TYPE_SUBMIT"}:
+        return bool(_TEXT_ASKED.search(asked))
+    if operation not in {"TAP", "SUBMIT"} or role not in NAVIGATION_TAP_ROLES:
+        return False
+    acts = {m.group(0).casefold() for m in re.finditer(r"[A-Za-z]+", label or "")
+            if STATE_CHANGING_LABEL.fullmatch(m.group(0)) or SIDE_EFFECT_CONTROL.fullmatch(m.group(0))
+            or COMMIT_CONTROL.fullmatch(m.group(0)) or CHANGE_REQUEST.fullmatch(m.group(0))}
+    if not acts:
+        return True
+    return all((_inflections(act) | synonyms(act)) & words for act in acts)

mobile_agent/team_signing/__init__.py

@@ -0,0 +1,34 @@
+"""Pro without Xcode, for a paid Apple Developer team (PRO-WITHOUT-XCODE.md, 18 Oct 2026).
+
+Mobster signs its helper (the WebDriverAgent runner) on this Mac and installs it with open-source device tooling,
+so a phone-station Mac needs no Xcode:
+
+- ``writes``: the three App Store Connect writes (register an iPhone, create a development certificate, create a
+  development profile) as a card the person approves, with the ledger (``ledger``) that makes each attempt durable.
+- ``identity``: the certificate signing request and the signing key, kept in a Keychain only Mobster opens.
+- ``resign``: ``codesign`` of the prebuilt runner with the team's profile, and the check that it verifies.
+- ``tooling``: install and launch the signed runner with pymobiledevice3 (go-ios as the fallback), never ``xcodebuild``.
+- ``bundle``: Path C, a signed runner and its profile exported from one Mac and imported on another.
+
+Off unless ``MOBSTER_EXPERIMENTAL_NO_XCODE=1``. Free Apple Accounts keep today's Xcode flow. Nothing here uses
+Apple's private sign-in endpoints or changes how the phone looks to an app.
+"""
+
+import os
+from pathlib import Path
+
+FLAG = "MOBSTER_EXPERIMENTAL_NO_XCODE"
+
+
+def enabled(environ=None):
+    """Whether signing without Xcode is on (``MOBSTER_EXPERIMENTAL_NO_XCODE=1``)."""
+    environ = os.environ if environ is None else environ
+    return str(environ.get(FLAG, "")).strip().casefold() in ("1", "true", "yes", "on")
+
+
+def state_dir(data_dir=None):
+    """Where this feature keeps its files (the ledger, the certificate, the signed runners): a folder only you can
+    open, in Mobster's data folder."""
+    from .. import env_file, paths
+
+    return env_file.private_dir(Path(data_dir) if data_dir is not None else paths.user_data_dir()) / "team-signing"