primocode 9.4.0 → 9.6.0

package/voz/primo_voz/__main__.py

@@ -50,7 +50,7 @@ from pathlib import Path
 AQUI = Path(__file__).resolve().parent
 sys.path.insert(0, str(AQUI.parent))
 
-from primo_voz import desperta, escuta, orbe  # noqa: E402
+from primo_voz import desperta, escuta, orbe, transcrever  # noqa: E402
 
 
 def falar_para_o_node(obj: dict) -> None:
@@ -135,6 +135,11 @@ class Voz:
                 self.desperta = None
 
         self.orb = orbe.Orbe(ao_fechar=self.parar)
+        # O Whisper local carrega em segundo plano desde já: senão a primeira
+        # frase esperaria o modelo inteiro subir.
+        self.local = transcrever.disponivel()
+        if self.local:
+            transcrever.aquecer()
         self.gravador = escuta.Gravador()
         self.corte = escuta.Corte()
 
@@ -251,11 +256,18 @@ class Voz:
 
     # ── transcrição ──────────────────────────────────────────────────────
     def _transcrever(self, wav: Path) -> str:
-        """Quem tem a chave é o servidor do PrimoCode, não este programa.
-
-        É a mesma rota que a legenda de vídeo usa. Duas formas de transcrever
-        seriam duas contas para pagar e duas para consertar.
+        """Primeiro aqui, com o Whisper local (ver transcrever.py). O servidor
+        só entra se o local não estiver instalado ou falhar — e diz que caiu.
         """
+        if self.local:
+            try:
+                return transcrever.transcrever(wav)
+            except Exception as e:
+                avisar(f"a transcrição local falhou ({e}); tentando pelo servidor.")
+        return self._transcrever_no_servidor(wav)
+
+    def _transcrever_no_servidor(self, wav: Path) -> str:
+        """A rota do servidor, a mesma que a legenda de vídeo usa."""
         import base64
         import urllib.request
 

package/voz/primo_voz/cursor.py

@@ -0,0 +1,525 @@
+"""cursor.py — o cursor do Primo: o mouse de verdade, com a cara dele.
+
+    "Quando ele tá no modo, eu consigo ver o cursor dele, o mouse, ver ele
+     digitando, abrindo as coisas, ver ele fazer as coisas em tempo real."
+     (23/09/2026)
+
+── O QUE É ─────────────────────────────────────────────────────────────────
+Um processo pequeno, só do macOS, que o Node sobe na primeira ação no
+computador. Ele faz duas coisas ao mesmo tempo, e é a soma das duas que dá a
+sensação de "ver o Primo trabalhando":
+
+1. MEXE NO MOUSE E NO TECLADO DE VERDADE, pelo Quartz (`CGEventPost`). Não é
+   um cursor de enfeite correndo por cima: o clique acontece no app que está
+   embaixo. Isso também aposenta o `cliclick`, que precisava de Homebrew e,
+   sem ele, fazia TODO clique falhar — foi por isso que "mostra o teu mouse"
+   virou uma página HTML com coordenadas.
+
+2. DESENHA O CURSOR DELE por cima do de verdade: uma seta escura com contorno
+   claro e brilho na cor da marca, um anel em volta, uma onda a cada clique e
+   uma etiqueta curta do que está fazendo ("digitando", "abrindo Safari").
+   Numa janela transparente, acima de tudo, que NÃO recebe clique (o clique
+   atravessa para o app) e que não aparece em captura de tela (o print que o
+   agente tira mostra a tela, não o cursor dele).
+
+O desenho é o do Jarvis (~/Jarvis/src/jarvis/ui/web/hud.html e
+motor/pointer.py): o mesmo trajeto em curva com aceleração suave — reta
+parece robô — e o mesmo sumiço 1,6 s depois da última ação, devolvendo a tela
+ao cursor da pessoa.
+
+── O PROTOCOLO ─────────────────────────────────────────────────────────────
+Uma linha de JSON por comando no stdin, uma de resposta no stdout:
+
+    {"id": 1, "cmd": "clicar", "x": 400, "y": 300, "botao": "esquerdo", "duplo": false}
+    {"id": 1, "ok": true}
+
+Comandos: mover, clicar, arrastar, rolar, digitar, tecla, rotulo, ocupado,
+esconder, permissao, tamanho. Coordenadas em PONTOS da tela principal, com a
+origem no canto de cima à esquerda — as mesmas do System Events, que é de onde
+vêm as posições dos botões.
+"""
+from __future__ import annotations
+
+import json
+import math
+import random
+import sys
+import threading
+import time
+
+import objc
+import Quartz
+from AppKit import (NSApplication, NSBezierPath, NSColor, NSFont, NSMakeRect,
+                    NSObject, NSScreen, NSShadow, NSTimer, NSView, NSWindow,
+                    NSBackingStoreBuffered, NSCompositingOperationClear,
+                    NSRectFillUsingOperation, NSFontAttributeName,
+                    NSForegroundColorAttributeName)
+from Foundation import NSString
+from PyObjCTools import AppHelper
+
+# ── A cara ──────────────────────────────────────────────────────────────────
+CORES = {
+    "normal": (0.37, 0.91, 1.0),     # ciano da marca
+    "agindo": (1.0, 0.71, 0.32),     # âmbar: está mexendo em alguma coisa
+}
+PASSOS_HZ = 120            # quantas vezes por segundo o mouse anda no trajeto
+SOME_DEPOIS = 1.6          # segundos parado até o cursor dele sumir
+NIVEL = 1000               # NSScreenSaverWindowLevel: acima de qualquer app
+
+
+def _cor(rgb, alfa=1.0):
+    return NSColor.colorWithSRGBRed_green_blue_alpha_(rgb[0], rgb[1], rgb[2], alfa)
+
+
+# ── O mouse e o teclado de verdade ──────────────────────────────────────────
+
+def _post(evento) -> None:
+    Quartz.CGEventPost(Quartz.kCGHIDEventTap, evento)
+
+
+def posicao():
+    p = Quartz.CGEventGetLocation(Quartz.CGEventCreate(None))
+    return float(p.x), float(p.y)
+
+
+def pode_agir() -> bool:
+    """O sistema deixa este processo mexer no mouse e no teclado?
+
+    `CGPreflightPostEventAccess` e não `AXIsProcessTrusted`: este último fica
+    em cache pela vida do processo, e continuava dizendo "não" depois de a
+    pessoa conceder a permissão (medido no Jarvis, motor/permissions.py).
+    """
+    try:
+        return bool(Quartz.CGPreflightPostEventAccess())
+    except Exception:
+        return True       # macOS antigo sem a função: tenta e vê
+
+
+def pedir_permissao() -> None:
+    try:
+        Quartz.CGRequestPostEventAccess()
+    except Exception:
+        pass
+
+
+# Códigos de tecla do layout americano: o atalho é pelo CÓDIGO, não pela
+# letra, então vale em qualquer layout de teclado.
+TECLAS = {
+    "a": 0, "s": 1, "d": 2, "f": 3, "h": 4, "g": 5, "z": 6, "x": 7, "c": 8, "v": 9,
+    "b": 11, "q": 12, "w": 13, "e": 14, "r": 15, "y": 16, "t": 17, "1": 18, "2": 19,
+    "3": 20, "4": 21, "6": 22, "5": 23, "=": 24, "9": 25, "7": 26, "-": 27, "8": 28,
+    "0": 29, "]": 30, "o": 31, "u": 32, "[": 33, "i": 34, "p": 35, "l": 37, "j": 38,
+    "'": 39, "k": 40, ";": 41, "\\": 42, ",": 43, "/": 44, "n": 45, "m": 46, ".": 47,
+    "`": 50,
+    "enter": 36, "return": 36, "tab": 48, "space": 49, "espaco": 49, "espaço": 49,
+    "delete": 51, "backspace": 51, "apagar": 51, "esc": 53, "escape": 53,
+    "forwarddelete": 117, "del": 117, "home": 115, "end": 119, "pageup": 116,
+    "pagedown": 121, "left": 123, "esquerda": 123, "right": 124, "direita": 124,
+    "down": 125, "baixo": 125, "up": 126, "cima": 126,
+    "f1": 122, "f2": 120, "f3": 99, "f4": 118, "f5": 96, "f6": 97, "f7": 98,
+    "f8": 100, "f9": 101, "f10": 109, "f11": 103, "f12": 111,
+}
+MODIFICADORES = {
+    "cmd": Quartz.kCGEventFlagMaskCommand, "command": Quartz.kCGEventFlagMaskCommand,
+    "super": Quartz.kCGEventFlagMaskCommand, "win": Quartz.kCGEventFlagMaskCommand,
+    "meta": Quartz.kCGEventFlagMaskCommand,
+    "ctrl": Quartz.kCGEventFlagMaskControl, "control": Quartz.kCGEventFlagMaskControl,
+    "alt": Quartz.kCGEventFlagMaskAlternate, "option": Quartz.kCGEventFlagMaskAlternate,
+    "opt": Quartz.kCGEventFlagMaskAlternate,
+    "shift": Quartz.kCGEventFlagMaskShift,
+}
+
+
+def combo(nome: str):
+    """"cmd+shift+t" → (código, flags). None se a tecla não for conhecida."""
+    partes = [p.strip().lower() for p in str(nome).replace(" ", "").split("+") if p.strip()]
+    if not partes:
+        return None
+    flags = 0
+    for p in partes[:-1]:
+        if p not in MODIFICADORES:
+            return None
+        flags |= MODIFICADORES[p]
+    tecla = partes[-1]
+    if tecla not in TECLAS:
+        return None
+    return TECLAS[tecla], flags
+
+
+def apertar(codigo: int, flags: int = 0) -> None:
+    for desce in (True, False):
+        ev = Quartz.CGEventCreateKeyboardEvent(None, codigo, desce)
+        if flags:
+            Quartz.CGEventSetFlags(ev, flags)
+        _post(ev)
+        time.sleep(0.012)
+
+
+def digitar(texto: str) -> None:
+    """Letra por letra, pelo caractere — acento e emoji saem certos em
+    qualquer layout de teclado. Quebra de linha é Return de verdade."""
+    for ch in str(texto):
+        if ch == "\n":
+            apertar(36)
+        elif ch == "\t":
+            apertar(48)
+        else:
+            for desce in (True, False):
+                ev = Quartz.CGEventCreateKeyboardEvent(None, 0, desce)
+                Quartz.CGEventKeyboardSetUnicodeString(ev, len(ch), ch)
+                _post(ev)
+            time.sleep(0.008)
+
+
+# ── A janela do cursor ──────────────────────────────────────────────────────
+
+class VistaCursor(NSView):
+    """Pinta o cursor do Primo. Coordenadas viradas: y cresce para baixo,
+    como as do Quartz — o mesmo número serve para os dois."""
+
+    def initWithFrame_(self, quadro):
+        self = objc.super(VistaCursor, self).initWithFrame_(quadro)
+        if self is None:
+            return None
+        self.x, self.y = posicao()
+        self.alfa = 0.0          # 0..1, para aparecer e sumir sem piscar
+        self.visivel = False
+        self.estado = "normal"
+        self.rotulo = ""
+        self.ocupado = False
+        self.ondas = []          # [(x, y, começo)] de cada clique
+        self.fase = 0.0
+        self.ultima = 0.0        # hora da última ação
+        return self
+
+    def isFlipped(self):
+        return True
+
+    def isOpaque(self):
+        return False
+
+    def drawRect_(self, rect):
+        NSColor.clearColor().set()
+        NSRectFillUsingOperation(self.bounds(), NSCompositingOperationClear)
+        if self.alfa <= 0.01 and not self.ondas:
+            return
+        a = self.alfa
+        cor = CORES.get(self.estado, CORES["normal"])
+        x, y = self.x, self.y
+        agora = time.time()
+
+        # A ONDA de cada clique: um anel que abre e some em meio segundo.
+        vivas = []
+        for (ox, oy, t0) in self.ondas:
+            t = (agora - t0) / 0.5
+            if t >= 1:
+                continue
+            vivas.append((ox, oy, t0))
+            r = 6 + 30 * t
+            _cor(cor, (1 - t) * 0.9).set()
+            anel = NSBezierPath.bezierPathWithOvalInRect_(NSMakeRect(ox - r, oy - r, 2 * r, 2 * r))
+            anel.setLineWidth_(2.5 * (1 - t) + 0.5)
+            anel.stroke()
+        self.ondas = vivas
+
+        if a <= 0.01:
+            return
+
+        # HALO: um anel cheio e um tracejado girando, em volta da ponta.
+        _cor(cor, 0.35 * a).set()
+        halo = NSBezierPath.bezierPathWithOvalInRect_(NSMakeRect(x - 20, y - 20, 40, 40))
+        halo.setLineWidth_(1.5)
+        halo.stroke()
+        _cor(cor, 0.55 * a).set()
+        giro = NSBezierPath.bezierPathWithOvalInRect_(NSMakeRect(x - 14, y - 14, 28, 28))
+        giro.setLineWidth_(1.2)
+        giro.setLineDash_count_phase_([4.0, 5.0], 2, self.fase * 18)
+        giro.stroke()
+
+        # A SETA: escura e cheia (para cobrir a seta do sistema embaixo), com
+        # contorno claro e brilho na cor do estado. A ponta é o ponto do mouse.
+        pontos = [(0, 0), (0, 25), (6.2, 19.4), (10.6, 29.2), (14.6, 27.4), (10.3, 17.9), (18.5, 17.9)]
+        seta = NSBezierPath.bezierPath()
+        seta.moveToPoint_((x + pontos[0][0], y + pontos[0][1]))
+        for (px, py) in pontos[1:]:
+            seta.lineToPoint_((x + px, y + py))
+        seta.closePath()
+        sombra = NSShadow.alloc().init()
+        sombra.setShadowColor_(_cor(cor, 0.9 * a))
+        sombra.setShadowBlurRadius_(10)
+        sombra.setShadowOffset_((0, 0))
+        from AppKit import NSGraphicsContext
+        NSGraphicsContext.saveGraphicsState()
+        sombra.set()
+        NSColor.colorWithSRGBRed_green_blue_alpha_(0.02, 0.043, 0.075, 0.96 * a).set()
+        seta.fill()
+        NSGraphicsContext.restoreGraphicsState()
+        NSColor.colorWithSRGBRed_green_blue_alpha_(0.92, 0.98, 1.0, a).set()
+        seta.setLineWidth_(1.6)
+        seta.setLineJoinStyle_(1)
+        seta.stroke()
+        # o núcleo de energia dentro da seta
+        _cor(cor, a).set()
+        NSBezierPath.bezierPathWithOvalInRect_(NSMakeRect(x + 3.2, y + 10.5, 5, 5)).fill()
+
+        # OCUPADO: um arco girando embaixo à direita da seta.
+        if self.ocupado:
+            _cor(cor, 0.9 * a).set()
+            arco = NSBezierPath.bezierPath()
+            arco.appendBezierPathWithArcWithCenter_radius_startAngle_endAngle_(
+                (x + 24, y + 30), 6, self.fase * 360 % 360, (self.fase * 360 + 250) % 360)
+            arco.setLineWidth_(2)
+            arco.stroke()
+
+        # A ETIQUETA do que ele está fazendo.
+        if self.rotulo:
+            atributos = {
+                NSFontAttributeName: NSFont.systemFontOfSize_weight_(12, 0.3),
+                NSForegroundColorAttributeName: NSColor.colorWithSRGBRed_green_blue_alpha_(0.95, 0.98, 1.0, a),
+            }
+            texto = NSString.stringWithString_(self.rotulo)
+            tam = texto.sizeWithAttributes_(atributos)
+            bx, by = x + 22, y + 34
+            caixa = NSBezierPath.bezierPathWithRoundedRect_xRadius_yRadius_(
+                NSMakeRect(bx, by, tam.width + 18, tam.height + 8), 9, 9)
+            NSColor.colorWithSRGBRed_green_blue_alpha_(0.03, 0.06, 0.1, 0.86 * a).set()
+            caixa.fill()
+            _cor(cor, 0.6 * a).set()
+            caixa.setLineWidth_(1)
+            caixa.stroke()
+            texto.drawAtPoint_withAttributes_((bx + 9, by + 4), atributos)
+
+
+class Relogio(NSObject):
+    """Anima o cursor a 60 quadros por segundo, na thread da interface."""
+
+    def initComVista_(self, vista):
+        self = objc.super(Relogio, self).init()
+        if self is None:
+            return None
+        self.vista = vista
+        return self
+
+    def tique_(self, _timer):
+        v = self.vista
+        v.fase += 1 / 60
+        parado = time.time() - v.ultima
+        alvo = 1.0 if (v.visivel and (v.ocupado or parado < SOME_DEPOIS)) else 0.0
+        v.alfa += (alvo - v.alfa) * 0.25
+        if alvo == 0.0 and v.alfa < 0.02:
+            v.alfa = 0.0
+            if not v.ocupado:
+                v.rotulo = ""
+        v.setNeedsDisplay_(True)
+
+
+class Cursor:
+    def __init__(self):
+        self.app = NSApplication.sharedApplication()
+        self.app.setActivationPolicy_(1)          # acessório: sem ícone no Dock
+        tela = NSScreen.screens()[0].frame()      # a tela principal (origem 0,0)
+        self.largura, self.altura = tela.size.width, tela.size.height
+        self.janela = NSWindow.alloc().initWithContentRect_styleMask_backing_defer_(
+            tela, 0, NSBackingStoreBuffered, False)
+        j = self.janela
+        j.setOpaque_(False)
+        j.setBackgroundColor_(NSColor.clearColor())
+        j.setHasShadow_(False)
+        j.setLevel_(NIVEL)
+        j.setIgnoresMouseEvents_(True)            # o clique atravessa para o app
+        # Fora das capturas de tela (o print do agente mostra a tela, não o
+        # cursor dele). PRIMO_CURSOR_CAPTURAVEL=1 libera, para o teste fotografar.
+        import os
+        j.setSharingType_(1 if os.environ.get("PRIMO_CURSOR_CAPTURAVEL") == "1" else 0)
+        j.setCollectionBehavior_(1 | 16 | 64 | 256)
+        self.vista = VistaCursor.alloc().initWithFrame_(NSMakeRect(0, 0, self.largura, self.altura))
+        j.setContentView_(self.vista)
+        j.orderFrontRegardless()
+        self.relogio = Relogio.alloc().initComVista_(self.vista)
+        NSTimer.scheduledTimerWithTimeInterval_target_selector_userInfo_repeats_(
+            1 / 60, self.relogio, "tique:", None, True)
+
+    # ── o que a interface mostra (sempre na thread dela) ────────────────────
+    def _ui(self, **campos):
+        def aplicar():
+            for k, v in campos.items():
+                setattr(self.vista, k, v)
+            self.vista.ultima = time.time()
+        AppHelper.callAfter(aplicar)
+
+    def _onda(self, x, y):
+        AppHelper.callAfter(lambda: self.vista.ondas.append((x, y, time.time())))
+
+    # ── o trajeto ───────────────────────────────────────────────────────────
+    def mover(self, x: float, y: float, arrastando: bool = False) -> None:
+        """Vai até (x, y) numa curva leve, acelerando e freando.
+
+        Reta com velocidade constante é o que denuncia robô. O ponto de
+        controle da curva sai para o lado, proporcional à distância, com teto.
+        """
+        x = max(0.0, min(self.largura - 1, float(x)))
+        y = max(0.0, min(self.altura - 1, float(y)))
+        x0, y0 = posicao()
+        dist = math.hypot(x - x0, y - y0)
+        self._ui(visivel=True, estado="agindo")
+        if dist < 1:
+            self._ui(x=x, y=y)
+            return
+        dur = max(0.14, min(1.2, 0.22 + dist / 1700))
+        passos = max(2, int(dur * PASSOS_HZ))
+        desvio = min(dist * 0.12, 90) * random.choice((-1, 1))
+        mx, my = (x0 + x) / 2, (y0 + y) / 2
+        nx, ny = -(y - y0) / dist, (x - x0) / dist
+        cx, cy = mx + nx * desvio, my + ny * desvio
+        tipo = Quartz.kCGEventLeftMouseDragged if arrastando else Quartz.kCGEventMouseMoved
+        for i in range(1, passos + 1):
+            t = i / passos
+            e = 0.5 - 0.5 * math.cos(math.pi * t)
+            px = (1 - e) ** 2 * x0 + 2 * (1 - e) * e * cx + e ** 2 * x
+            py = (1 - e) ** 2 * y0 + 2 * (1 - e) * e * cy + e ** 2 * y
+            _post(Quartz.CGEventCreateMouseEvent(None, tipo, (px, py), Quartz.kCGMouseButtonLeft))
+            if i % 2 == 0 or i == passos:
+                self._ui(x=px, y=py)
+            time.sleep(dur / passos)
+
+    def clicar(self, x, y, botao="esquerdo", duplo=False) -> None:
+        self.mover(x, y)
+        time.sleep(0.04)          # o app vê o mouse chegar antes do clique
+        direito = str(botao).lower() in ("direito", "right")
+        desce = Quartz.kCGEventRightMouseDown if direito else Quartz.kCGEventLeftMouseDown
+        sobe = Quartz.kCGEventRightMouseUp if direito else Quartz.kCGEventLeftMouseUp
+        qual = Quartz.kCGMouseButtonRight if direito else Quartz.kCGMouseButtonLeft
+        for n in ((1, 2) if duplo else (1,)):
+            for tipo in (desce, sobe):
+                ev = Quartz.CGEventCreateMouseEvent(None, tipo, (x, y), qual)
+                Quartz.CGEventSetIntegerValueField(ev, Quartz.kCGMouseEventClickState, n)
+                _post(ev)
+            self._onda(x, y)
+            time.sleep(0.09)
+
+    def arrastar(self, x1, y1, x2, y2) -> None:
+        self.mover(x1, y1)
+        _post(Quartz.CGEventCreateMouseEvent(None, Quartz.kCGEventLeftMouseDown, (x1, y1), Quartz.kCGMouseButtonLeft))
+        time.sleep(0.12)
+        self.mover(x2, y2, arrastando=True)
+        _post(Quartz.CGEventCreateMouseEvent(None, Quartz.kCGEventLeftMouseUp, (x2, y2), Quartz.kCGMouseButtonLeft))
+        self._onda(x2, y2)
+
+    def rolar(self, dy) -> None:
+        linhas = int(round(float(dy) / 50)) or (1 if float(dy) > 0 else -1)
+        x, y = posicao()
+        self._ui(visivel=True, x=x, y=y)
+        passo = -1 if linhas > 0 else 1        # dy > 0 rola para BAIXO
+        for _ in range(abs(linhas)):
+            _post(Quartz.CGEventCreateScrollWheelEvent(None, Quartz.kCGScrollEventUnitLine, 1, passo * 3))
+            time.sleep(0.03)
+
+
+# ── O laço de comandos ──────────────────────────────────────────────────────
+
+def responder(obj) -> None:
+    sys.stdout.write(json.dumps(obj, ensure_ascii=False) + "\n")
+    sys.stdout.flush()
+
+
+def executar(cur: Cursor, msg: dict) -> dict:
+    cmd = msg.get("cmd")
+    if cmd == "permissao":
+        ok = pode_agir()
+        if not ok and msg.get("pedir"):
+            pedir_permissao()
+        return {"ok": ok}
+    if cmd == "tamanho":
+        return {"ok": True, "largura": int(cur.largura), "altura": int(cur.altura)}
+    if cmd == "rotulo":
+        cur._ui(rotulo=str(msg.get("texto") or "")[:48], visivel=True, x=posicao()[0], y=posicao()[1])
+        return {"ok": True}
+    if cmd == "ocupado":
+        cur._ui(ocupado=bool(msg.get("sim")), visivel=True)
+        return {"ok": True}
+    if cmd == "esconder":
+        cur._ui(visivel=False, ocupado=False, rotulo="")
+        return {"ok": True}
+    if cmd == "foto":
+        # Só para o teste: renderiza a vista do cursor numa imagem, em volta
+        # dele. Não é captura de tela (a janela fica fora delas de propósito).
+        import os
+        if os.environ.get("PRIMO_CURSOR_CAPTURAVEL") != "1":
+            return {"ok": False, "error": "foto só no modo de teste"}
+        feito = threading.Event()
+        saida = {}
+        def render():
+            v = cur.vista
+            area = NSMakeRect(max(0, v.x - 60), max(0, v.y - 60), 240, 160)
+            rep = v.bitmapImageRepForCachingDisplayInRect_(area)
+            v.cacheDisplayInRect_toBitmapImageRep_(area, rep)
+            rep.representationUsingType_properties_(4, None).writeToFile_atomically_(msg["caminho"], True)
+            saida.update(alfa=round(v.alfa, 2), x=v.x, y=v.y)
+            feito.set()
+        AppHelper.callAfter(render)
+        feito.wait(3)
+        return {"ok": bool(saida), **saida}
+
+    # Daqui para baixo, mexe no computador: sem a permissão, o sistema engole
+    # os eventos calado. Melhor dizer do que fingir que clicou.
+    if not pode_agir():
+        pedir_permissao()
+        return {"ok": False, "permissao": False,
+                "error": "o macOS não deixou mexer no mouse e no teclado. Libere o Terminal (ou o app "
+                         "de onde você abriu o PrimoCode) em Ajustes do Sistema > Privacidade e "
+                         "Segurança > Acessibilidade, e peça de novo."}
+    if "rotulo" in msg:
+        cur._ui(rotulo=str(msg.get("rotulo") or "")[:48])
+    if cmd == "mover":
+        cur.mover(msg["x"], msg["y"])
+    elif cmd == "clicar":
+        cur.clicar(msg["x"], msg["y"], msg.get("botao", "esquerdo"), bool(msg.get("duplo")))
+    elif cmd == "arrastar":
+        cur.arrastar(msg["x1"], msg["y1"], msg["x2"], msg["y2"])
+    elif cmd == "rolar":
+        cur.rolar(msg.get("dy", 300))
+    elif cmd == "digitar":
+        cur._ui(visivel=True, x=posicao()[0], y=posicao()[1], ocupado=True)
+        digitar(msg.get("texto", ""))
+        cur._ui(ocupado=False)
+    elif cmd == "tecla":
+        c = combo(msg.get("combo", ""))
+        if not c:
+            return {"ok": False, "error": f'tecla desconhecida: "{msg.get("combo")}". Use nomes como '
+                                          '"enter", "esc", "tab", "cmd+t", "cmd+shift+4", "left".'}
+        cur._ui(visivel=True, x=posicao()[0], y=posicao()[1])
+        apertar(*c)
+    else:
+        return {"ok": False, "error": f"comando desconhecido: {cmd}"}
+    return {"ok": True}
+
+
+def ler_comandos(cur: Cursor) -> None:
+    for linha in sys.stdin:
+        linha = linha.strip()
+        if not linha:
+            continue
+        try:
+            msg = json.loads(linha)
+        except ValueError:
+            continue
+        try:
+            r = executar(cur, msg)
+        except Exception as e:           # um comando ruim não derruba o cursor
+            r = {"ok": False, "error": str(e)}
+        r["id"] = msg.get("id")
+        responder(r)
+    # stdin fechou: o PrimoCode saiu. O cursor sai junto.
+    AppHelper.callAfter(AppHelper.stopEventLoop)
+
+
+def main() -> int:
+    cur = Cursor()
+    threading.Thread(target=ler_comandos, args=(cur,), daemon=True).start()
+    responder({"pronto": True, "permissao": pode_agir()})
+    AppHelper.runEventLoop(installInterrupt=True)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())