arona-agent 1.0.0

package/python/_i18n.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+"""ARONA i18n 辅助（仅用于 stderr 人读日志；stdout 协议通道禁止使用）。
+
+语言判定优先级：ARONA_LANG（Node 注入，最可靠）> LANG 环境变量。
+协议通道（stdout JSON / READY / 事件名 / 识别文本）为结构豁免，不得翻译。
+"""
+
+import os
+
+
+def is_en() -> bool:
+    """是否英文模式。ARONA_LANG 由 Node 侧 src/utils/python.ts 注入。"""
+    return (os.environ.get("ARONA_LANG") or os.environ.get("LANG") or "").startswith("en")
+
+
+def t(zh: str, en: str) -> str:
+    """按当前语言返回中英两版文案之一。"""
+    return en if is_en() else zh

package/python/computer_use.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""
+ARONA Computer Use - cua wrapper (local-only)
+Persistent process that reads JSON commands from stdin, writes JSON responses to stdout.
+
+Commands:
+  {"action": "screenshot"}                          -> {"screenshot": "<base64>"}
+  {"action": "click", "x": 100, "y": 200}           -> {"screenshot": "<base64>"}
+  {"action": "click", "x": 100, "y": 200, "button": "right"}  -> {"screenshot": "<base64>"}
+  {"action": "type", "text": "hello"}               -> {"screenshot": "<base64>"}
+  {"action": "key", "keys": ["ctrl", "c"]}          -> {"screenshot": "<base64>"}
+  {"action": "scroll", "x": 100, "y": 200, "direction": "down", "amount": 3} -> {"screenshot": "<base64>"}
+  {"action": "move", "x": 100, "y": 200}            -> {"screenshot": "<base64>"}
+"""
+
+import asyncio
+import json
+import sys
+import traceback
+
+from _i18n import t
+
+
+# 需要 macOS 辅助功能权限的操作（pynput 控制鼠标/键盘；截图不需要）
+_AX_REQUIRED_ACTIONS = {"click", "type", "key", "scroll", "move"}
+
+
+def check_accessibility_permission() -> bool:
+    """检查 macOS 辅助功能权限（pynput 控制鼠标/键盘需要此权限，截图不需要）。"""
+    import platform
+    if platform.system() != "Darwin":
+        return True
+    try:
+        import ctypes
+        lib = ctypes.cdll.LoadLibrary(
+            '/System/Library/Frameworks/ApplicationServices.framework/ApplicationServices'
+        )
+        lib.AXIsProcessTrustedWithOptions.restype = ctypes.c_bool
+        lib.AXIsProcessTrustedWithOptions.argtypes = [ctypes.c_void_p]
+        return lib.AXIsProcessTrustedWithOptions(None)
+    except Exception:
+        return True  # 检查失败时不阻止操作
+
+
+def check_screen_capture_permission() -> bool:
+    """检查 macOS 屏幕录制权限（截图需要此权限；未授权时静默返回空白图）。"""
+    import platform
+    if platform.system() != "Darwin":
+        return True
+    try:
+        import ctypes
+        lib = ctypes.cdll.LoadLibrary(
+            '/System/Library/Frameworks/CoreGraphics.framework/CoreGraphics'
+        )
+        lib.CGPreflightScreenCaptureAccess.restype = ctypes.c_bool
+        lib.CGPreflightScreenCaptureAccess.argtypes = []
+        return lib.CGPreflightScreenCaptureAccess()
+    except Exception:
+        return True  # 老版本 macOS 无此 API，不阻止
+
+
+async def main():
+    # 检查 macOS 辅助功能权限（pynput 控制鼠标/键盘需要此权限，截图不受影响）
+    has_ax_permission = check_accessibility_permission()
+    if not has_ax_permission:
+        print(t(
+            "WARNING: 未授予 macOS 辅助功能权限，鼠标/键盘操作将无法生效（截图不受影响）",
+            "WARNING: macOS Accessibility permission not granted — mouse/keyboard actions will not work (screenshot unaffected)",
+        ), file=sys.stderr, flush=True)
+        print(t(
+            "修复方法：系统设置 > 隐私与安全性 > 辅助功能 > 启用运行此程序的终端应用",
+            "To fix: System Settings > Privacy & Security > Accessibility > enable the terminal app running this program",
+        ), file=sys.stderr, flush=True)
+
+    # 检查 macOS 屏幕录制权限（截图需要此权限；未授权时静默返回空白图，不报错但 AI 看不到真实屏幕）
+    has_screen_permission = check_screen_capture_permission()
+    if not has_screen_permission:
+        print(t(
+            "WARNING: 未授予 macOS 屏幕录制权限，截图将返回空白图（不报错但 AI 看不到真实屏幕内容）",
+            "WARNING: macOS Screen Recording permission not granted — screenshots will return a blank image (no error, but the AI cannot see the real screen)",
+        ), file=sys.stderr, flush=True)
+        print(t(
+            "修复方法：系统设置 > 隐私与安全性 > 屏幕录制 > 启用运行此程序的终端应用",
+            "To fix: System Settings > Privacy & Security > Screen Recording > enable the terminal app running this program",
+        ), file=sys.stderr, flush=True)
+
+    # Sandbox mode is hard-wired to local (controls the local machine's mouse/keyboard)
+    try:
+        from cua import Localhost
+        computer = await Localhost.connect()
+    except Exception as e:
+        print(json.dumps({"error": f"Failed to connect to cua Localhost: {e}"}), flush=True)
+        sys.exit(1)
+
+    # Signal ready
+    print("READY", flush=True)
+
+    # Read commands from stdin
+    loop = asyncio.get_event_loop()
+
+    while True:
+        try:
+            line = await loop.run_in_executor(None, sys.stdin.readline)
+            if not line:
+                break
+
+            line = line.strip()
+            if not line:
+                continue
+
+            cmd = json.loads(line)
+            if not isinstance(cmd, dict):
+                print(json.dumps({"error": "Expected JSON object"}), flush=True)
+                continue
+            action = cmd.get("action", "")
+
+            result = {}
+
+            if action in _AX_REQUIRED_ACTIONS and not has_ax_permission:
+                result = {"error": "macOS 辅助功能权限未授予，无法执行鼠标/键盘操作。请到「系统设置 > 隐私与安全性 > 辅助功能」中为终端应用授权。"}
+
+            elif action == "screenshot" and not has_screen_permission:
+                result = {"error": "macOS 屏幕录制权限未授予，截图将返回空白图。请到「系统设置 > 隐私与安全性 > 屏幕录制」中为终端应用授权。"}
+
+            elif action == "screenshot":
+                b64 = await computer.screenshot_base64()
+                result = {"screenshot": b64}
+
+            elif action == "click":
+                x = cmd["x"]
+                y = cmd["y"]
+                button = cmd.get("button", "left")
+                if button == "right":
+                    await computer.mouse.right_click(x, y)
+                elif button == "double":
+                    await computer.mouse.double_click(x, y)
+                else:
+                    await computer.mouse.click(x, y)
+                b64 = await computer.screenshot_base64()
+                result = {"screenshot": b64}
+
+            elif action == "type":
+                text = cmd["text"]
+                await computer.keyboard.type(text)
+                b64 = await computer.screenshot_base64()
+                result = {"screenshot": b64}
+
+            elif action == "key":
+                keys = cmd["keys"]
+                await computer.keyboard.keypress(keys)
+                b64 = await computer.screenshot_base64()
+                result = {"screenshot": b64}
+
+            elif action == "scroll":
+                x = cmd["x"]
+                y = cmd["y"]
+                direction = cmd.get("direction", "down")
+                amount = cmd.get("amount", 3)
+                # pynput 语义：正 dy = 向上滚动，负 dy = 向下滚动
+                scroll_y = -amount if direction == "down" else amount
+                await computer.mouse.scroll(x, y, scroll_x=0, scroll_y=scroll_y)
+                b64 = await computer.screenshot_base64()
+                result = {"screenshot": b64}
+
+            elif action == "move":
+                x = cmd["x"]
+                y = cmd["y"]
+                await computer.mouse.move(x, y)
+                b64 = await computer.screenshot_base64()
+                result = {"screenshot": b64}
+
+            else:
+                result = {"error": f"Unknown action: {action}"}
+
+            print(json.dumps(result), flush=True)
+
+        except json.JSONDecodeError:
+            print(json.dumps({"error": "Invalid JSON input"}), flush=True)
+        except Exception as e:
+            print(json.dumps({"error": str(e), "trace": traceback.format_exc()}), flush=True)
+
+    # Cleanup
+    try:
+        await computer.disconnect()
+    except Exception:
+        pass
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/python/hotkey.py

@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+"""
+ARONA 全局热键监听 - pynput 实现
+
+常驻进程，监听全局键盘事件。检测到右 Cmd 长按 >= 2 秒时，
+向 stdout 输出一行 JSON {"event":"trigger"}，Node 端接收后触发 STT 录音。
+
+启动时输出 READY 表示就绪。
+退出时输出 {"event":"exit"}。
+
+环境变量：
+  ARONA_HOTKEY_KEY      - 热键名称（默认 cmd_r，即右 Cmd）
+  ARONA_HOTKEY_HOLD_MS  - 长按阈值（默认 2000 毫秒）
+"""
+
+import json
+import os
+import sys
+import time
+import threading
+
+from _i18n import t
+
+
+HOLD_MS = int(os.environ.get("ARONA_HOTKEY_HOLD_MS", "2000"))
+HOTKEY_NAME = os.environ.get("ARONA_HOTKEY_KEY", "cmd_r")
+
+# pynput key.code 映射
+KEY_CODES = {
+    "cmd_r": "cmd",
+    "cmd_l": "cmd",
+    "ctrl_r": "ctrl",
+    "ctrl_l": "ctrl",
+    "alt_r": "alt",
+    "alt_l": "alt",
+    "shift_r": "shift",
+    "shift_l": "shift",
+    "f8": "f8",
+}
+
+
+def emit(obj):
+    """输出 JSON 到 stdout 并 flush。"""
+    sys.stdout.write(json.dumps(obj) + "\n")
+    sys.stdout.flush()
+
+
+def main():
+    try:
+        from pynput import keyboard
+    except Exception as e:
+        print(t(f"hotkey: 导入 pynput 失败：{e}", f"hotkey: import pynput failed: {e}"), file=sys.stderr)
+        sys.exit(1)
+
+    # 目标 key code
+    target_code = KEY_CODES.get(HOTKEY_NAME, "cmd")
+    if HOTKEY_NAME not in KEY_CODES:
+        print(t(
+            f"hotkey: 未知的 ARONA_HOTKEY_KEY='{HOTKEY_NAME}'，回退到 'cmd'",
+            f"hotkey: unknown ARONA_HOTKEY_KEY='{HOTKEY_NAME}', falling back to 'cmd'",
+        ), file=sys.stderr)
+    target_is_right = HOTKEY_NAME.endswith("_r")
+
+    state = {"pressed_at": None, "fired": False, "lock": threading.Lock()}
+
+    def on_press(key):
+        # 判断是否目标键
+        code = None
+        is_right = None
+        try:
+            # pynput 的 key 可能是 KeyCode 或 Key
+            if hasattr(key, "name"):
+                code = key.name
+            elif hasattr(key, "value"):
+                code = key.value.vk if hasattr(key.value, "vk") else None
+            # 右修饰键判断：pynput 在 macOS 上用 Key.cmd / Key.cmd_l / Key.cmd_r
+            if key == keyboard.Key.cmd_r:
+                code = "cmd"
+                is_right = True
+            elif key == keyboard.Key.cmd_l:
+                code = "cmd"
+                is_right = False
+            elif key == keyboard.Key.ctrl_r:
+                code = "ctrl"
+                is_right = True
+            elif key == keyboard.Key.ctrl_l:
+                code = "ctrl"
+                is_right = False
+            elif key == keyboard.Key.alt_r:
+                code = "alt"
+                is_right = True
+            elif key == keyboard.Key.alt_l:
+                code = "alt"
+                is_right = False
+            elif key == keyboard.Key.shift_r:
+                code = "shift"
+                is_right = True
+            elif key == keyboard.Key.shift_l:
+                code = "shift"
+                is_right = False
+            elif key == keyboard.Key.f8:
+                code = "f8"
+                is_right = None
+        except Exception:
+            return
+
+        if code != target_code:
+            return
+        if target_is_right and is_right is not True:
+            return
+        if not target_is_right and is_right is True and target_code in ("cmd", "ctrl", "alt", "shift"):
+            # 左键模式：排除右键
+            return
+
+        with state["lock"]:
+            if state["pressed_at"] is not None:
+                # 已按下，忽略重复
+                return
+            state["pressed_at"] = time.monotonic()
+            state["fired"] = False
+
+    def on_release(key):
+        code = None
+        is_right = None
+        try:
+            if key == keyboard.Key.cmd_r:
+                code = "cmd"
+                is_right = True
+            elif key == keyboard.Key.cmd_l:
+                code = "cmd"
+                is_right = False
+            elif key == keyboard.Key.ctrl_r:
+                code = "ctrl"
+                is_right = True
+            elif key == keyboard.Key.ctrl_l:
+                code = "ctrl"
+                is_right = False
+            elif key == keyboard.Key.alt_r:
+                code = "alt"
+                is_right = True
+            elif key == keyboard.Key.alt_l:
+                code = "alt"
+                is_right = False
+            elif key == keyboard.Key.shift_r:
+                code = "shift"
+                is_right = True
+            elif key == keyboard.Key.shift_l:
+                code = "shift"
+                is_right = False
+            elif key == keyboard.Key.f8:
+                code = "f8"
+                is_right = None
+        except Exception:
+            return
+
+        if code != target_code:
+            return
+        if target_is_right and is_right is not True:
+            return
+
+        with state["lock"]:
+            state["pressed_at"] = None
+            state["fired"] = False
+
+    # 长按检测线程：轮询检查是否达到阈值
+    def hold_checker():
+        while True:
+            time.sleep(0.1)
+            with state["lock"]:
+                pressed_at = state["pressed_at"]
+                fired = state["fired"]
+                if pressed_at is not None and not fired:
+                    elapsed_ms = (time.monotonic() - pressed_at) * 1000
+                    if elapsed_ms >= HOLD_MS:
+                        state["fired"] = True
+                        emit({"event": "trigger"})
+            # 检查主线程是否还活着
+            if not threading.main_thread().is_alive():
+                break
+
+    checker_thread = threading.Thread(target=hold_checker, daemon=True)
+    checker_thread.start()
+
+    emit({"event": "ready"})
+
+    try:
+        with keyboard.Listener(on_press=on_press, on_release=on_release) as listener:
+            listener.join()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        emit({"event": "exit"})
+
+
+if __name__ == "__main__":
+    main()

package/python/stt.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""
+ARONA STT - Qwen ASR (阿里云百炼 DashScope) 实时语音识别客户端
+录音并流式上传，返回识别文本到 stdout。
+
+环境变量：
+  QWEN_WORKSPACE_ID     - 百炼业务空间 ID（可选；留空走旧域名 dashscope.aliyuncs.com）
+  QWEN_STT_API_KEY      - 百炼 API Key
+  QWEN_STT_MODEL        - 模型名（默认 qwen-audio-3.0-asr-flash-streaming）
+  QWEN_STT_FORMAT       - 音频格式（默认 pcm）
+  QWEN_STT_SAMPLE_RATE  - 采样率（默认 16000）
+
+流程：run-task → (等 task-started) → 录音并 send_bytes → finish-task
+识别结果在 result-generated 的 payload.output.sentence 中，
+sentence_end=true 为最终结果，聚合后输出到 stdout。
+"""
+
+import json
+import os
+import sys
+import uuid
+import asyncio
+import traceback
+
+from _i18n import t
+
+# 录音参数
+CHUNK_DURATION_MS = 200
+MAX_RECORDING_SECONDS = 15
+SILENCE_THRESHOLD = 500      # RMS 阈值
+SILENCE_DURATION_MS = 1500   # 静音超过此时长则结束
+
+
+def build_uri(workspace_id):
+    if workspace_id:
+        return f"wss://{workspace_id}.cn-beijing.maas.aliyuncs.com/api-ws/v1/inference"
+    return "wss://dashscope.aliyuncs.com/api-ws/v1/inference"
+
+
+async def receive_results(ws):
+    """持续接收识别结果，返回最终聚合文本。"""
+    final_text = ""
+    last_partial = ""
+    while True:
+        try:
+            msg = await asyncio.wait_for(ws.recv(), timeout=5.0)
+        except asyncio.TimeoutError:
+            break
+
+        if isinstance(msg, (bytes, bytearray)):
+            continue
+
+        try:
+            data = json.loads(msg)
+        except Exception:
+            continue
+
+        header = data.get("header", {})
+        event = header.get("event")
+
+        if event == "result-generated":
+            sentence = data.get("payload", {}).get("output", {}).get("sentence", {})
+            text = sentence.get("text", "")
+            if sentence.get("sentence_end"):
+                final_text += text
+                last_partial = ""  # 该句已终结，清空部分结果
+            else:
+                # 保留最新部分结果，防止长句在 sentence_end 前被截断而丢字
+                last_partial = text
+        elif event == "task-finished":
+            break
+        elif event == "task-failed":
+            err_code = header.get("error_code", "")
+            err_msg = header.get("error_message", "")
+            print(t(f"STT task-failed: {err_code} {err_msg}", f"STT task-failed: {err_code} {err_msg}"), file=sys.stderr)
+            break
+
+    # 若最后一段未收到 sentence_end，补上已识别的部分结果
+    return final_text + last_partial
+
+
+async def stt_recognize(api_key, workspace_id, model, audio_format, sample_rate):
+    import websockets
+    import pyaudio
+    import numpy as np
+
+    uri = build_uri(workspace_id)
+    task_id = str(uuid.uuid4())
+    headers = {
+        "Authorization": f"bearer {api_key}",
+        "X-DashScope-DataInspection": "enable",
+    }
+
+    channels = 1
+    sample_width = 2  # 16-bit
+    frames_per_buffer = int(sample_rate * CHUNK_DURATION_MS / 1000)
+
+    run_task = {
+        "header": {
+            "action": "run-task",
+            "task_id": task_id,
+            "streaming": "duplex",
+        },
+        "payload": {
+            "task_group": "audio",
+            "task": "asr",
+            "function": "recognition",
+            "model": model,
+            "parameters": {
+                "format": audio_format,
+                "sample_rate": sample_rate,
+            },
+            "input": {},
+        },
+    }
+
+    pa = None
+    stream = None
+    final_text = ""
+    try:
+        pa = pyaudio.PyAudio()
+        stream = pa.open(
+            format=pyaudio.paInt16,
+            channels=channels,
+            rate=sample_rate,
+            input=True,
+            frames_per_buffer=frames_per_buffer,
+        )
+
+        async with websockets.connect(uri, additional_headers=headers, max_size=64 * 1024 * 1024, proxy=None) as ws:
+            await ws.send(json.dumps(run_task))
+
+            # 等 task-started
+            started = False
+            while not started:
+                try:
+                    msg = await asyncio.wait_for(ws.recv(), timeout=30.0)
+                except asyncio.TimeoutError:
+                    print(t("STT: 等待 task-started 超时", "STT: timeout waiting for task-started"), file=sys.stderr)
+                    return ""
+                if isinstance(msg, (bytes, bytearray)):
+                    continue
+                try:
+                    data = json.loads(msg)
+                except Exception:
+                    # 非 JSON 消息，跳过继续等待 task-started
+                    continue
+                ev = data.get("header", {}).get("event")
+                if ev == "task-started":
+                    started = True
+                elif ev == "task-failed":
+                    err = data.get("header", {})
+                    print(t(f"STT task-failed: {err.get('error_code')} {err.get('error_message')}", f"STT task-failed: {err.get('error_code')} {err.get('error_message')}"), file=sys.stderr)
+                    return ""
+
+            # 后台接收结果
+            receive_task = asyncio.create_task(receive_results(ws))
+
+            # 录音并上传
+            silence_start = None
+            speech_started = False  # 首次检测到声音后才开始静音计时，给用户反应宽限
+            total_chunks = 0
+            max_chunks = int(MAX_RECORDING_SECONDS * 1000 / CHUNK_DURATION_MS)
+
+            print(t("正在录音…请说话", "Recording... (speak now)"), file=sys.stderr)
+
+            while total_chunks < max_chunks:
+                audio_data = stream.read(frames_per_buffer, exception_on_overflow=False)
+
+                # 静音检测
+                samples = np.frombuffer(audio_data, dtype=np.int16)
+                rms = float(np.sqrt(np.mean(samples.astype(np.float64) ** 2)))
+                if rms < SILENCE_THRESHOLD:
+                    if speech_started:
+                        if silence_start is None:
+                            silence_start = total_chunks
+                        elif (total_chunks - silence_start) * CHUNK_DURATION_MS >= SILENCE_DURATION_MS:
+                            break
+                else:
+                    silence_start = None
+                    speech_started = True
+
+                # 发送二进制音频帧
+                await ws.send(audio_data)
+                total_chunks += 1
+
+            # 结束任务
+            finish_task = {
+                "header": {
+                    "action": "finish-task",
+                    "task_id": task_id,
+                    "streaming": "duplex",
+                },
+                "payload": {
+                    "input": {},
+                },
+            }
+            await ws.send(json.dumps(finish_task))
+
+            try:
+                final_text = await asyncio.wait_for(receive_task, timeout=10.0)
+            except asyncio.TimeoutError:
+                final_text = ""
+
+    except Exception as e:
+        print(t(f"STT 错误：{e}", f"STT error: {e}"), file=sys.stderr)
+        traceback.print_exc(file=sys.stderr)
+    finally:
+        if stream is not None:
+            try:
+                stream.stop_stream()
+                stream.close()
+            except Exception:
+                pass
+        if pa is not None:
+            try:
+                pa.terminate()
+            except Exception:
+                pass
+
+    return final_text
+
+
+def main():
+    api_key = os.environ.get("QWEN_STT_API_KEY", "")
+    workspace_id = os.environ.get("QWEN_WORKSPACE_ID", "")
+    model = os.environ.get("QWEN_STT_MODEL", "qwen-audio-3.0-asr-flash-streaming")
+    audio_format = os.environ.get("QWEN_STT_FORMAT", "pcm")
+    sample_rate = int(os.environ.get("QWEN_STT_SAMPLE_RATE", "16000"))
+
+    if not api_key:
+        print(t("STT: 未设置 QWEN_STT_API_KEY", "STT: QWEN_STT_API_KEY not set"), file=sys.stderr)
+        sys.exit(1)
+
+    text = asyncio.run(stt_recognize(api_key, workspace_id, model, audio_format, sample_rate))
+    print(text)
+
+
+if __name__ == "__main__":
+    main()