autoglm.js 0.0.6 → 0.0.7

package/dist/index.mjs

@@ -1,36 +1,1862 @@
-import { a as emitter, m as setAgentConfig, n as checkSystemRequirements, r as PhoneAgent, t as checkModelApi } from "./check-DHb6ZElP.mjs";
+import { exec } from "tinyexec";
+import { execSync } from "node:child_process";
+import path, { join } from "node:path";
+import fs from "fs-extra";
+import { isLinux, isMacOS, isWindows } from "std-env";
+import os, { tmpdir } from "node:os";
+import dayjs from "dayjs";
+import "dayjs/locale/zh-cn.js";
+import { Buffer } from "node:buffer";
+import { unlink } from "node:fs/promises";
+import { parse } from "acorn-loose";
+import { randomUUID } from "node:crypto";
+import sharp from "sharp";
+import mitt from "mitt";
+import OpenAI from "openai";
 
-//#region src/index.ts
-var AutoGLM = class AutoGLM {
-	phoneAgent;
+//#region src/adb/constants.ts
+const CONNECTION_TYPE = {
+	USB: "usb",
+	TCPIP: "tcpip"
+};
+
+//#endregion
+//#region src/constants/app.ts
+/**
+* Mapping of app names to their package names.
+*/
+const APP_PACKAGES = {
+	"微信": "com.tencent.mm",
+	"QQ": "com.tencent.mobileqq",
+	"微博": "com.sina.weibo",
+	"淘宝": "com.taobao.taobao",
+	"京东": "com.jingdong.app.mall",
+	"拼多多": "com.xunmeng.pinduoduo",
+	"淘宝闪购": "com.taobao.taobao",
+	"京东秒送": "com.jingdong.app.mall",
+	"小红书": "com.xingin.xhs",
+	"豆瓣": "com.douban.frodo",
+	"知乎": "com.zhihu.android",
+	"高德地图": "com.autonavi.minimap",
+	"百度地图": "com.baidu.BaiduMap",
+	"美团": "com.sankuai.meituan",
+	"大众点评": "com.dianping.v1",
+	"饿了么": "me.ele",
+	"肯德基": "com.yek.android.kfc.activitys",
+	"携程": "ctrip.android.view",
+	"铁路12306": "com.MobileTicket",
+	"12306": "com.MobileTicket",
+	"去哪儿": "com.Qunar",
+	"去哪儿旅行": "com.Qunar",
+	"滴滴出行": "com.sdu.didi.psnger",
+	"航旅纵横": "com.umetrip.android.msky.app",
+	"bilibili": "tv.danmaku.bili",
+	"抖音": "com.ss.android.ugc.aweme",
+	"快手": "com.smile.gifmaker",
+	"腾讯视频": "com.tencent.qqlive",
+	"爱奇艺": "com.qiyi.video",
+	"优酷视频": "com.youku.phone",
+	"芒果TV": "com.hunantv.imgo.activity",
+	"红果短剧": "com.phoenix.read",
+	"网易云音乐": "com.netease.cloudmusic",
+	"QQ音乐": "com.tencent.qqmusic",
+	"汽水音乐": "com.luna.music",
+	"喜马拉雅": "com.ximalaya.ting.android",
+	"番茄小说": "com.dragon.read",
+	"番茄免费小说": "com.dragon.read",
+	"七猫免费小说": "com.kmxs.reader",
+	"飞书": "com.ss.android.lark",
+	"QQ邮箱": "com.tencent.androidqqmail",
+	"豆包": "com.larus.nova",
+	"keep": "com.gotokeep.keep",
+	"美柚": "com.lingan.seeyou",
+	"腾讯新闻": "com.tencent.news",
+	"今日头条": "com.ss.android.article.news",
+	"贝壳找房": "com.lianjia.beike",
+	"安居客": "com.anjuke.android.app",
+	"同花顺": "com.hexin.plat.android",
+	"星穹铁道": "com.miHoYo.hkrpg",
+	"崩坏：星穹铁道": "com.miHoYo.hkrpg",
+	"恋与深空": "com.papegames.lysk.cn",
+	"建设银行": "com.jingdong.app.mall",
+	"AndroidSystemSettings": "com.android.settings",
+	"Android System Settings": "com.android.settings",
+	"Android  System Settings": "com.android.settings",
+	"Android-System-Settings": "com.android.settings",
+	"Settings": "com.android.settings",
+	"AudioRecorder": "com.android.soundrecorder",
+	"audiorecorder": "com.android.soundrecorder",
+	"Bluecoins": "com.rammigsoftware.bluecoins",
+	"bluecoins": "com.rammigsoftware.bluecoins",
+	"Broccoli": "com.flauschcode.broccoli",
+	"broccoli": "com.flauschcode.broccoli",
+	"Booking.com": "com.booking",
+	"Booking": "com.booking",
+	"booking.com": "com.booking",
+	"booking": "com.booking",
+	"BOOKING.COM": "com.booking",
+	"Chrome": "com.android.chrome",
+	"chrome": "com.android.chrome",
+	"Google Chrome": "com.android.chrome",
+	"Clock": "com.android.deskclock",
+	"clock": "com.android.deskclock",
+	"Contacts": "com.android.contacts",
+	"contacts": "com.android.contacts",
+	"Duolingo": "com.duolingo",
+	"duolingo": "com.duolingo",
+	"Expedia": "com.expedia.bookings",
+	"expedia": "com.expedia.bookings",
+	"Files": "com.android.fileexplorer",
+	"files": "com.android.fileexplorer",
+	"File Manager": "com.android.fileexplorer",
+	"file manager": "com.android.fileexplorer",
+	"gmail": "com.google.android.gm",
+	"Gmail": "com.google.android.gm",
+	"GoogleMail": "com.google.android.gm",
+	"Google Mail": "com.google.android.gm",
+	"GoogleFiles": "com.google.android.apps.nbu.files",
+	"googlefiles": "com.google.android.apps.nbu.files",
+	"FilesbyGoogle": "com.google.android.apps.nbu.files",
+	"GoogleCalendar": "com.google.android.calendar",
+	"Google-Calendar": "com.google.android.calendar",
+	"Google Calendar": "com.google.android.calendar",
+	"google-calendar": "com.google.android.calendar",
+	"google calendar": "com.google.android.calendar",
+	"GoogleChat": "com.google.android.apps.dynamite",
+	"Google Chat": "com.google.android.apps.dynamite",
+	"Google-Chat": "com.google.android.apps.dynamite",
+	"GoogleClock": "com.google.android.deskclock",
+	"Google Clock": "com.google.android.deskclock",
+	"Google-Clock": "com.google.android.deskclock",
+	"GoogleContacts": "com.google.android.contacts",
+	"Google-Contacts": "com.google.android.contacts",
+	"Google Contacts": "com.google.android.contacts",
+	"google-contacts": "com.google.android.contacts",
+	"google contacts": "com.google.android.contacts",
+	"GoogleDocs": "com.google.android.apps.docs.editors.docs",
+	"Google Docs": "com.google.android.apps.docs.editors.docs",
+	"googledocs": "com.google.android.apps.docs.editors.docs",
+	"google docs": "com.google.android.apps.docs.editors.docs",
+	"Google Drive": "com.google.android.apps.docs",
+	"Google-Drive": "com.google.android.apps.docs",
+	"google drive": "com.google.android.apps.docs",
+	"google-drive": "com.google.android.apps.docs",
+	"GoogleDrive": "com.google.android.apps.docs",
+	"Googledrive": "com.google.android.apps.docs",
+	"googledrive": "com.google.android.apps.docs",
+	"GoogleFit": "com.google.android.apps.fitness",
+	"googlefit": "com.google.android.apps.fitness",
+	"GoogleKeep": "com.google.android.keep",
+	"googlekeep": "com.google.android.keep",
+	"GoogleMaps": "com.google.android.apps.maps",
+	"Google Maps": "com.google.android.apps.maps",
+	"googlemaps": "com.google.android.apps.maps",
+	"google maps": "com.google.android.apps.maps",
+	"Google Play Books": "com.google.android.apps.books",
+	"Google-Play-Books": "com.google.android.apps.books",
+	"google play books": "com.google.android.apps.books",
+	"google-play-books": "com.google.android.apps.books",
+	"GooglePlayBooks": "com.google.android.apps.books",
+	"googleplaybooks": "com.google.android.apps.books",
+	"GooglePlayStore": "com.android.vending",
+	"Google Play Store": "com.android.vending",
+	"Google-Play-Store": "com.android.vending",
+	"GoogleSlides": "com.google.android.apps.docs.editors.slides",
+	"Google Slides": "com.google.android.apps.docs.editors.slides",
+	"Google-Slides": "com.google.android.apps.docs.editors.slides",
+	"GoogleTasks": "com.google.android.apps.tasks",
+	"Google Tasks": "com.google.android.apps.tasks",
+	"Google-Tasks": "com.google.android.apps.tasks",
+	"Joplin": "net.cozic.joplin",
+	"joplin": "net.cozic.joplin",
+	"McDonald": "com.mcdonalds.app",
+	"mcdonald": "com.mcdonalds.app",
+	"Osmand": "net.osmand",
+	"osmand": "net.osmand",
+	"PiMusicPlayer": "com.Project100Pi.themusicplayer",
+	"pimusicplayer": "com.Project100Pi.themusicplayer",
+	"Quora": "com.quora.android",
+	"quora": "com.quora.android",
+	"Reddit": "com.reddit.frontpage",
+	"reddit": "com.reddit.frontpage",
+	"RetroMusic": "code.name.monkey.retromusic",
+	"retromusic": "code.name.monkey.retromusic",
+	"SimpleCalendarPro": "com.scientificcalculatorplus.simplecalculator.basiccalculator.mathcalc",
+	"SimpleSMSMessenger": "com.simplemobiletools.smsmessenger",
+	"Telegram": "org.telegram.messenger",
+	"temu": "com.einnovation.temu",
+	"Temu": "com.einnovation.temu",
+	"Tiktok": "com.zhiliaoapp.musically",
+	"tiktok": "com.zhiliaoapp.musically",
+	"Twitter": "com.twitter.android",
+	"twitter": "com.twitter.android",
+	"X": "com.twitter.android",
+	"VLC": "org.videolan.vlc",
+	"WeChat": "com.tencent.mm",
+	"wechat": "com.tencent.mm",
+	"Whatsapp": "com.whatsapp",
+	"WhatsApp": "com.whatsapp"
+};
+/**
+* List all supported apps.
+*/
+function listSupportedApps() {
+	return Object.keys(APP_PACKAGES);
+}
+
+//#endregion
+//#region src/constants/errorCodes.ts
+let ErrorCode = /* @__PURE__ */ function(ErrorCode$1) {
+	/** unknown error */
+	ErrorCode$1[ErrorCode$1["UNKNOWN_ERROR"] = 0] = "UNKNOWN_ERROR";
+	/** adb not installed */
+	ErrorCode$1[ErrorCode$1["ADB_NOT_INSTALLED"] = 1] = "ADB_NOT_INSTALLED";
+	/** adb device not connected */
+	ErrorCode$1[ErrorCode$1["ADB_DEVICE_UNCONNECTED"] = 2] = "ADB_DEVICE_UNCONNECTED";
+	/** adb keyboard not installed */
+	ErrorCode$1[ErrorCode$1["ADB_KEYBOARD_UNINSTALLED"] = 3] = "ADB_KEYBOARD_UNINSTALLED";
+	/** model api check failed */
+	ErrorCode$1[ErrorCode$1["MODEL_API_CHECK_FAILED"] = 4] = "MODEL_API_CHECK_FAILED";
+	return ErrorCode$1;
+}({});
+
+//#endregion
+//#region src/constants/filePath.ts
+const AUTOGLM_FILEPATH = join(os.homedir(), ".autoglm");
+
+//#endregion
+//#region src/constants/prompts_en.ts
+/**
+* English system prompt for the agent.
+*/
+const formatted_date$1 = dayjs().format("YYYY-MM-DD dddd");
+const SYSTEM_PROMPT_EN = `The current date: ${formatted_date$1}.
+You are a phone intelligent assistant built based on AutoGLM, capable of understanding user needs through natural language and helping users complete tasks through automated operations.
+
+# Setup
+You are a professional Android operation agent assistant that can fulfill the user's high-level instructions. Given a screenshot of the Android interface at each step, you first analyze the situation, then plan the best course of action using Python-style pseudo-code.
+
+# More details about the code
+Your response format must be structured as follows:
+
+Think first: Use <think>...</think> to analyze the current screen, identify key elements, and determine the most efficient action.
+Provide the action: Use <answer>...</answer> to return a single line of pseudo-code representing the operation.
+
+Your output should STRICTLY follow the format:
+<think>
+[Your thought]
+</think>
+<answer>
+[Your operation code]
+</answer>
+
+- **Tap**
+  Perform a tap action on a specified screen area. The element is a list of 2 integers, representing the coordinates of the tap point.
+  **Example**:
+  <answer>
+  do(action="Tap", element=[x,y])
+  </answer>
+- **Type**
+  Enter text into the currently focused input field.
+  **Example**:
+  <answer>
+  do(action="Type", text="Hello World")
+  </answer>
+- **Swipe**
+  Perform a swipe action with start point and end point.
+  **Examples**:
+  <answer>
+  do(action="Swipe", start=[x1,y1], end=[x2,y2])
+  </answer>
+- **Long Press**
+  Perform a long press action on a specified screen area.
+  You can add the element to the action to specify the long press area. The element is a list of 2 integers, representing the coordinates of the long press point.
+  **Example**:
+  <answer>
+  do(action="Long Press", element=[x,y])
+  </answer>
+- **Launch**
+  Launch an app. Try to use launch action when you need to launch an app. Check the instruction to choose the right app before you use this action.
+  **Example**:
+  <answer>
+  do(action="Launch", app="Settings")
+  </answer>
+- **Back**
+  Press the Back button to navigate to the previous screen.
+  **Example**:
+  <answer>
+  do(action="Back")
+  </answer>
+- **Finish**
+  Terminate the program and optionally print a message.
+  **Example**:
+  <answer>
+  finish(message="Task completed.")
+  </answer>
+
+
+REMEMBER:
+- Think before you act: Always analyze the current UI and the best course of action before executing any step, and output in <think> part.
+- Only ONE LINE of action in <answer> part per response: Each step must contain exactly one line of executable code.
+- Generate execution code strictly according to format requirements.
+`;
+
+//#endregion
+//#region src/constants/prompts_zh.ts
+dayjs.locale("zh-cn");
+const formatted_date = dayjs().format("YYYY-MM-DD dddd");
+/**
+* Chinese system prompt for the agent.
+*/
+const SYSTEM_PROMPT_ZH = `今天的日期是: ${formatted_date}
+你是一个智能体分析专家，可以根据操作历史和当前状态图执行一系列操作来完成任务。
+你必须严格按照要求输出以下格式：
+<think>{think}</think>
+<answer>{action}</answer>
+
+其中：
+- {think} 是对你为什么选择这个操作的简短推理说明。
+- {action} 是本次执行的具体操作指令，必须严格遵循下方定义的指令格式。
+
+操作指令及其作用如下：
+- do(action="Launch", app="xxx")
+    Launch是启动目标app的操作，这比通过主屏幕导航更快。此操作完成后，您将自动收到结果状态的截图。
+- do(action="Tap", element=[x,y])
+    Tap是点击操作，点击屏幕上的特定点。可用此操作点击按钮、选择项目、从主屏幕打开应用程序，或与任何可点击的用户界面元素进行交互。坐标系统从左上角 (0,0) 开始到右下角（999,999)结束。此操作完成后，您将自动收到结果状态的截图。
+- do(action="Tap", element=[x,y], message="重要操作")
+    基本功能同Tap，点击涉及财产、支付、隐私等敏感按钮时触发。
+- do(action="Type", text="xxx")
+    Type是输入操作，在当前聚焦的输入框中输入文本。使用此操作前，请确保输入框已被聚焦（先点击它）。输入的文本将像使用键盘输入一样输入。重要提示：手机可能正在使用 ADB 键盘，该键盘不会像普通键盘那样占用屏幕空间。要确认键盘已激活，请查看屏幕底部是否显示 'ADB Keyboard {ON}' 类似的文本，或者检查输入框是否处于激活/高亮状态。不要仅仅依赖视觉上的键盘显示。自动清除文本：当你使用输入操作时，输入框中现有的任何文本（包括占位符文本和实际输入）都会在输入新文本前自动清除。你无需在输入前手动清除文本——直接使用输入操作输入所需文本即可。操作完成后，你将自动收到结果状态的截图。
+- do(action="Type_Name", text="xxx")
+    Type_Name是输入人名的操作，基本功能同Type。
+- do(action="Interact")
+    Interact是当有多个满足条件的选项时而触发的交互操作，询问用户如何选择。
+- do(action="Swipe", start=[x1,y1], end=[x2,y2])
+    Swipe是滑动操作，通过从起始坐标拖动到结束坐标来执行滑动手势。可用于滚动内容、在屏幕之间导航、下拉通知栏以及项目栏或进行基于手势的导航。坐标系统从左上角 (0,0) 开始到右下角（999,999)结束。滑动持续时间会自动调整以实现自然的移动。此操作完成后，您将自动收到结果状态的截图。
+- do(action="Note", message="True")
+    记录当前页面内容以便后续总结。
+- do(action="Call_API", instruction="xxx")
+    总结或评论当前页面或已记录的内容。
+- do(action="Long Press", element=[x,y])
+    Long Pres是长按操作，在屏幕上的特定点长按指定时间。可用于触发上下文菜单、选择文本或激活长按交互。坐标系统从左上角 (0,0) 开始到右下角（999,999)结束。此操作完成后，您将自动收到结果状态的屏幕截图。
+- do(action="Double Tap", element=[x,y])
+    Double Tap在屏幕上的特定点快速连续点按两次。使用此操作可以激活双击交互，如缩放、选择文本或打开项目。坐标系统从左上角 (0,0) 开始到右下角（999,999)结束。此操作完成后，您将自动收到结果状态的截图。
+- do(action="Take_over", message="xxx")
+    Take_over是接管操作，表示在登录和验证阶段需要用户协助。
+- do(action="Back")
+    导航返回到上一个屏幕或关闭当前对话框。相当于按下 Android 的返回按钮。使用此操作可以从更深的屏幕返回、关闭弹出窗口或退出当前上下文。此操作完成后，您将自动收到结果状态的截图。
+- do(action="Home")
+    Home是回到系统桌面的操作，相当于按下 Android 主屏幕按钮。使用此操作可退出当前应用并返回启动器，或从已知状态启动新任务。此操作完成后，您将自动收到结果状态的截图。
+- do(action="Wait", duration="x seconds")
+    等待页面加载，x为需要等待多少秒。
+- finish(message="xxx")
+    finish是结束任务的操作，表示准确完整完成任务，message是终止信息。
+
+必须遵循的规则：
+1. 在执行任何操作前，先检查当前app是否是目标app，如果不是，先执行 Launch。
+2. 如果进入到了无关页面，先执行 Back。如果执行Back后页面没有变化，请点击页面左上角的返回键进行返回，或者右上角的X号关闭。
+3. 如果页面未加载出内容，最多连续 Wait 三次，否则执行 Back重新进入。
+4. 如果页面显示网络问题，需要重新加载，请点击重新加载。
+5. 如果当前页面找不到目标联系人、商品、店铺等信息，可以尝试 Swipe 滑动查找。
+6. 遇到价格区间、时间区间等筛选条件，如果没有完全符合的，可以放宽要求。
+7. 在做小红书总结类任务时一定要筛选图文笔记。
+8. 购物车全选后再点击全选可以把状态设为全不选，在做购物车任务时，如果购物车里已经有商品被选中时，你需要点击全选后再点击取消全选，再去找需要购买或者删除的商品。
+9. 在做外卖任务时，如果相应店铺购物车里已经有其他商品你需要先把购物车清空再去购买用户指定的外卖。
+10. 在做点外卖任务时，如果用户需要点多个外卖，请尽量在同一店铺进行购买，如果无法找到可以下单，并说明某个商品未找到。
+11. 请严格遵循用户意图执行任务，用户的特殊要求可以执行多次搜索，滑动查找。比如（i）用户要求点一杯咖啡，要咸的，你可以直接搜索咸咖啡，或者搜索咖啡后滑动查找咸的咖啡，比如海盐咖啡。（ii）用户要找到XX群，发一条消息，你可以先搜索XX群，找不到结果后，将"群"字去掉，搜索XX重试。（iii）用户要找到宠物友好的餐厅，你可以搜索餐厅，找到筛选，找到设施，选择可带宠物，或者直接搜索可带宠物，必要时可以使用AI搜索。
+12. 在选择日期时，如果原滑动方向与预期日期越来越远，请向反方向滑动查找。
+13. 执行任务过程中如果有多个可选择的项目栏，请逐个查找每个项目栏，直到完成任务，一定不要在同一项目栏多次查找，从而陷入死循环。
+14. 在执行下一步操作前请一定要检查上一步的操作是否生效，如果点击没生效，可能因为app反应较慢，请先稍微等待一下，如果还是不生效请调整一下点击位置重试，如果仍然不生效请跳过这一步继续任务，并在finish message说明点击不生效。
+15. 在执行任务中如果遇到滑动不生效的情况，请调整一下起始点位置，增大滑动距离重试，如果还是不生效，有可能是已经滑到底了，请继续向反方向滑动，直到顶部或底部，如果仍然没有符合要求的结果，请跳过这一步继续任务，并在finish message说明但没找到要求的项目。
+16. 在做游戏任务时如果在战斗页面如果有自动战斗一定要开启自动战斗，如果多轮历史状态相似要检查自动战斗是否开启。
+17. 如果没有合适的搜索结果，可能是因为搜索页面不对，请返回到搜索页面的上一级尝试重新搜索，如果尝试三次返回上一级搜索后仍然没有符合要求的结果，执行 finish(message="原因")。
+18. 在结束任务前请一定要仔细检查任务是否完整准确的完成，如果出现错选、漏选、多选的情况，请返回之前的步骤进行纠正。
+`;
+
+//#endregion
+//#region src/adb/installer.ts
+var ADBAutoInstaller = class {
+	installPath;
+	adbPath;
+	platformToolsPath;
+	globalADBChecked = null;
+	constructor(customPlatformToolsPath) {
+		this.installPath = AUTOGLM_FILEPATH;
+		this.platformToolsPath = customPlatformToolsPath ?? path.join(this.installPath, "platform-tools");
+		this.adbPath = path.join(this.platformToolsPath, "adb");
+	}
+	async install() {
+		if (await this.check()) return;
+		await fs.ensureDir(this.installPath);
+		if (isMacOS) {
+			const { installADB } = await import("@autoglm.js/platform-tools-darwin");
+			await installADB(this.installPath);
+		}
+		if (isLinux) {
+			const { installADB } = await import("@autoglm.js/platform-tools-linux");
+			await installADB(this.installPath);
+		}
+		if (isWindows) {
+			const { installADB } = await import("@autoglm.js/platform-tools-windows");
+			await installADB(this.installPath);
+		}
+	}
+	async check() {
+		return await fs.pathExists(this.adbPath);
+	}
+	checkGlobalADB() {
+		if (this.globalADBChecked !== null) return this.globalADBChecked;
+		try {
+			execSync("adb version", { stdio: "ignore" });
+			this.globalADBChecked = true;
+			return true;
+		} catch {
+			this.globalADBChecked = false;
+			return false;
+		}
+	}
+	get adb() {
+		return this.checkGlobalADB() ? "adb" : this.adbPath;
+	}
+};
+
+//#endregion
+//#region src/adb/connection.ts
+var ADBConnection = class {
+	adb;
+	constructor() {
+		this.adb = new ADBAutoInstaller().adb;
+	}
+	/**
+	* Get ADB version.
+	*/
+	async version() {
+		try {
+			const versionLine = (await exec(this.adb, ["version"])).stdout.trim().split("\n")[0];
+			const versionMatch = versionLine.match(/(\d+\.\d+\.\d+)/);
+			return {
+				success: true,
+				message: versionLine,
+				version: versionMatch ? versionMatch[1] : null
+			};
+		} catch (error) {
+			return {
+				success: false,
+				message: error instanceof Error ? error.message : "Unknown error",
+				version: null
+			};
+		}
+	}
+	/**
+	* Connect to a remote device.
+	*/
+	async connect(address) {
+		try {
+			const stdout = (await exec(this.adb, ["connect", address])).stdout.trim();
+			if (stdout.includes("connected to") || stdout.includes("already connected")) return {
+				success: true,
+				message: stdout
+			};
+			else return {
+				success: false,
+				message: stdout
+			};
+		} catch (error) {
+			return {
+				success: false,
+				message: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* Disconnect from a device.
+	*/
+	async disconnect(address) {
+		try {
+			const args = address ? ["disconnect", address] : ["disconnect"];
+			return {
+				success: true,
+				message: (await exec(this.adb, args)).stdout.trim()
+			};
+		} catch (error) {
+			return {
+				success: false,
+				message: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* Enable TCP/IP debugging on USB device.
+	*/
+	async enableTCPIP(port = 5555, deviceId) {
+		try {
+			const args = deviceId ? [
+				"-s",
+				deviceId,
+				"tcpip",
+				port.toString()
+			] : ["tcpip", port.toString()];
+			return {
+				success: true,
+				message: (await exec(this.adb, args)).stdout.trim()
+			};
+		} catch (error) {
+			return {
+				success: false,
+				message: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* Get device IP address.
+	*/
+	async getDeviceIp(deviceId) {
+		try {
+			const args = deviceId ? [
+				"-s",
+				deviceId,
+				"shell",
+				"ip",
+				"addr",
+				"show",
+				"wlan0"
+			] : [
+				"shell",
+				"ip",
+				"addr",
+				"show",
+				"wlan0"
+			];
+			const ipMatch = (await exec(this.adb, args)).stdout.match(/inet\s+(\d+\.\d+\.\d+\.\d+)/);
+			return ipMatch ? ipMatch[1] : null;
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* List all connected devices.
+	*/
+	async listDevices() {
+		const deviceLines = (await exec(this.adb, ["devices", "-l"])).stdout.trim().split("\n").slice(1).filter((line) => line.trim());
+		return await Promise.all(deviceLines.map(async (line) => {
+			const parts = line.split(/\s+/);
+			const deviceId = parts[0];
+			const status = parts[1];
+			const connectionType = deviceId.includes(":") ? CONNECTION_TYPE.TCPIP : CONNECTION_TYPE.USB;
+			let model;
+			for (const part of parts) if (part.startsWith("model:")) {
+				model = part.replace("model:", "");
+				break;
+			}
+			const deviceInfo = {
+				deviceId,
+				status,
+				connectionType,
+				model
+			};
+			if (status === "device") try {
+				const [brand, manufacturer, device, androidVersion, apiLevel] = await Promise.all([
+					this.getDeviceProp(deviceId, "ro.product.brand"),
+					this.getDeviceProp(deviceId, "ro.product.manufacturer"),
+					this.getDeviceProp(deviceId, "ro.product.device"),
+					this.getDeviceProp(deviceId, "ro.build.version.release"),
+					this.getDeviceProp(deviceId, "ro.build.version.sdk")
+				]);
+				deviceInfo.brand = brand || void 0;
+				deviceInfo.manufacturer = manufacturer || void 0;
+				deviceInfo.device = device || void 0;
+				deviceInfo.androidVersion = androidVersion || void 0;
+				deviceInfo.apiLevel = apiLevel || void 0;
+			} catch {}
+			return deviceInfo;
+		}));
+	}
+	/**
+	* Get device property value.
+	*/
+	async getDeviceProp(deviceId, prop) {
+		try {
+			return (await exec(this.adb, [
+				"-s",
+				deviceId,
+				"shell",
+				"getprop",
+				prop
+			])).stdout.trim() || null;
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Check device is connected.
+	*/
+	async devices() {
+		try {
+			const devices = (await exec(this.adb, ["devices"])).stdout.trim().split("\n").slice(1).filter((line) => line.trim() && line.includes("	device"));
+			if (devices.length === 0) return {
+				success: false,
+				message: "No devices connected"
+			};
+			else return {
+				success: true,
+				message: devices.map((d) => d.split("	")[0]).join(", ")
+			};
+		} catch (error) {
+			return {
+				success: false,
+				message: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/utils/errorMessage.ts
+function getErrorMessage(error, defaultMessage = "Unknown error") {
+	return error instanceof Error ? error.message : defaultMessage;
+}
+
+//#endregion
+//#region src/adb/utils.ts
+/**
+* Get ADB command prefix with optional device specifier.
+*/
+async function getAdbPrefix(deviceId) {
+	const adb = new ADBAutoInstaller().adb;
+	return deviceId ? [
+		adb,
+		"-s",
+		deviceId
+	] : [adb];
+}
+async function runAdbCommand(deviceId, args, timeout) {
+	const prefix = await getAdbPrefix(deviceId);
+	if (timeout) return await exec(prefix[0], [...prefix.slice(1), ...args], { timeout });
+	else return await exec(prefix[0], [...prefix.slice(1), ...args]);
+}
+
+//#endregion
+//#region src/adb/keyboard.ts
+var ADBKeyboard = class {
+	ctx;
+	constructor(context) {
+		this.ctx = context;
+	}
+	get deviceId() {
+		return this.ctx.getConfig().deviceId;
+	}
+	/**
+	* Check ADB Keyboard is installed.
+	*/
+	async isKeyboardInstalled() {
+		try {
+			if ((await runAdbCommand(this.deviceId, [
+				"shell",
+				"ime",
+				"list",
+				"-s"
+			])).stdout.trim().includes("com.android.adbkeyboard/.AdbIME")) return {
+				success: true,
+				message: "ADB Keyboard is installed and enabled"
+			};
+			else return {
+				success: false,
+				message: "ADB Keyboard is not installed"
+			};
+		} catch (error) {
+			return {
+				success: false,
+				message: getErrorMessage(error)
+			};
+		}
+	}
+	/**
+	* Install ADB Keyboard.
+	*/
+	async installKeyboard(customApkPath) {
+		try {
+			const { installKeyboard } = await import("@autoglm.js/adb-keyboard");
+			await installKeyboard(this.deviceId, customApkPath);
+			return {
+				success: true,
+				message: "ADB Keyboard installed and enabled"
+			};
+		} catch (error) {
+			return {
+				success: false,
+				message: getErrorMessage(error)
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/adb/manager.ts
+var ADBManager = class {
+	ctx;
+	connection;
+	keyboard;
+	constructor(context) {
+		this.ctx = context;
+		this.connection = new ADBConnection();
+		this.keyboard = new ADBKeyboard(context);
+	}
+	async install(customPlatformToolsPath) {
+		await new ADBAutoInstaller(customPlatformToolsPath).install();
+	}
+	async getVersion() {
+		return this.connection.version();
+	}
+	async getConnectedDevices() {
+		return this.connection.listDevices();
+	}
+	async devices() {
+		return this.connection.devices();
+	}
+	async connect(address) {
+		return this.connection.connect(address);
+	}
+	async disconnect(address) {
+		return this.connection.disconnect(address);
+	}
+	async enableTCPIP(port = 5555, deviceId) {
+		return this.connection.enableTCPIP(port, deviceId);
+	}
+	async getDeviceIp(deviceId) {
+		return this.connection.getDeviceIp(deviceId);
+	}
+	async isKeyboardInstalled() {
+		return this.keyboard.isKeyboardInstalled();
+	}
+	async installKeyboard(customApkPath) {
+		return this.keyboard.installKeyboard(customApkPath);
+	}
+};
+
+//#endregion
+//#region src/adb/device.ts
+/**
+* Get the currently focused app name.
+*/
+async function getCurrentApp(deviceId) {
+	const output = (await runAdbCommand(deviceId, [
+		"shell",
+		"dumpsys",
+		"window"
+	])).stdout;
+	for (const line of output.split("\n")) if (line.includes("mCurrentFocus") || line.includes("mFocusedApp")) {
+		for (const [appName, appPackage] of Object.entries(APP_PACKAGES)) if (line.includes(appPackage)) return appName;
+	}
+	return "System Home";
+}
+/**
+* Tap at the specified coordinates.
+*/
+async function tap(x, y, deviceId, delay = 1) {
+	await runAdbCommand(deviceId, [
+		"shell",
+		"input",
+		"tap",
+		x.toString(),
+		y.toString()
+	]);
+	await new Promise((resolve) => setTimeout(resolve, delay * 1e3));
+}
+/**
+* Double tap at the specified coordinates.
+*/
+async function doubleTap(x, y, deviceId, delay = 1) {
+	await runAdbCommand(deviceId, [
+		"shell",
+		"input",
+		"tap",
+		x.toString(),
+		y.toString()
+	]);
+	await new Promise((resolve) => setTimeout(resolve, 100));
+	await runAdbCommand(deviceId, [
+		"shell",
+		"input",
+		"tap",
+		x.toString(),
+		y.toString()
+	]);
+	await new Promise((resolve) => setTimeout(resolve, delay * 1e3));
+}
+/**
+* Long press at the specified coordinates.
+*/
+async function longPress(x, y, durationMs = 3e3, deviceId, delay = 1) {
+	await runAdbCommand(deviceId, [
+		"shell",
+		"input",
+		"swipe",
+		x.toString(),
+		y.toString(),
+		x.toString(),
+		y.toString(),
+		durationMs.toString()
+	]);
+	await new Promise((resolve) => setTimeout(resolve, delay * 1e3));
+}
+/**
+* Swipe from start to end coordinates.
+*/
+async function swipe(startX, startY, endX, endY, durationMs, deviceId, delay = 1) {
+	if (durationMs === void 0) {
+		const distSq = (startX - endX) ** 2 + (startY - endY) ** 2;
+		durationMs = Math.max(1e3, Math.min(Math.floor(distSq / 1e3), 2e3));
+	}
+	await runAdbCommand(deviceId, [
+		"shell",
+		"input",
+		"swipe",
+		startX.toString(),
+		startY.toString(),
+		endX.toString(),
+		endY.toString(),
+		durationMs.toString()
+	]);
+	await new Promise((resolve) => setTimeout(resolve, delay * 1e3));
+}
+/**
+* Press the back button.
+*/
+async function back(deviceId, delay = 1) {
+	await runAdbCommand(deviceId, [
+		"shell",
+		"input",
+		"keyevent",
+		"4"
+	]);
+	await new Promise((resolve) => setTimeout(resolve, delay * 1e3));
+}
+/**
+* Press the home button.
+*/
+async function home(deviceId, delay = 1) {
+	await runAdbCommand(deviceId, [
+		"shell",
+		"input",
+		"keyevent",
+		"KEYCODE_HOME"
+	]);
+	await new Promise((resolve) => setTimeout(resolve, delay * 1e3));
+}
+/**
+* Launch an app by name.
+*/
+async function launchApp(appName, deviceId, delay = 1) {
+	if (!APP_PACKAGES[appName]) return false;
+	const appPackage = APP_PACKAGES[appName];
+	await runAdbCommand(deviceId, [
+		"shell",
+		"monkey",
+		"-p",
+		appPackage,
+		"-c",
+		"android.intent.category.LAUNCHER",
+		"1"
+	]);
+	await new Promise((resolve) => setTimeout(resolve, delay * 1e3));
+	return true;
+}
+
+//#endregion
+//#region ../shared/src/utils.ts
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+//#endregion
+//#region src/adb/input.ts
+/**
+* Get the current input method (IME) on the device.
+* @param deviceId - Optional device ID for multi-device setups
+* @returns The current IME identifier (e.g., "com.google.android.inputmethod.latin/.LatinIME")
+*/
+async function getCurrentIme(deviceId) {
+	try {
+		const result = await runAdbCommand(deviceId, [
+			"shell",
+			"settings",
+			"get",
+			"secure",
+			"default_input_method"
+		]);
+		return (result.stdout + result.stderr).trim();
+	} catch (error) {
+		console.warn(`Failed to get current IME: ${error instanceof Error ? error.message : "Unknown error"}`);
+		return "";
+	}
+}
+/**
+* Set the input method (IME) on the device.
+* @param ime - The IME identifier to set
+* @param deviceId - Optional device ID for multi-device setups
+*/
+async function setIme(ime, deviceId) {
+	if (!ime) {
+		console.warn("setIme called with empty IME identifier, skipping");
+		return;
+	}
+	try {
+		await runAdbCommand(deviceId, [
+			"shell",
+			"ime",
+			"set",
+			ime
+		]);
+	} catch (error) {
+		console.warn(`Failed to set IME to "${ime}": ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+/**
+* Detect if ADB Keyboard is available and set it as the default keyboard.
+* @returns The original IME identifier for later restoration
+*/
+async function detectAndSetAdbKeyboard(deviceId) {
+	const currentIme = await getCurrentIme(deviceId);
+	try {
+		if (!(await runAdbCommand(deviceId, [
+			"shell",
+			"pm",
+			"list",
+			"packages",
+			"com.android.adbkeyboard"
+		])).stdout.includes("com.android.adbkeyboard")) {
+			console.warn("ADB Keyboard is not installed");
+			return currentIme;
+		}
+		if (!currentIme.includes("com.android.adbkeyboard/.AdbIME")) {
+			await setIme("com.android.adbkeyboard/.AdbIME", deviceId);
+			await sleep(300);
+			await runAdbCommand(deviceId, [
+				"shell",
+				"am",
+				"broadcast",
+				"-a",
+				"ADB_INPUT_B64",
+				"--es",
+				"msg",
+				Buffer.from("", "utf8").toString("base64")
+			]);
+		}
+		return currentIme;
+	} catch (error) {
+		console.warn(`Failed to set ADB Keyboard: ${error instanceof Error ? error.message : "Unknown error"}`);
+		return currentIme;
+	}
+}
+/**
+* Restore the previous keyboard.
+* @param ime - The IME identifier to restore
+* @param deviceId - Optional device ID for multi-device setups
+*/
+async function restoreKeyboard(ime, deviceId) {
+	if (!ime) {
+		console.warn("restoreKeyboard called with empty IME identifier, skipping");
+		return;
+	}
+	if (ime.includes("com.android.adbkeyboard/.AdbIME")) return;
+	try {
+		await setIme(ime, deviceId);
+		await sleep(300);
+	} catch (error) {
+		console.warn(`Failed to restore keyboard: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+}
+/**
+* Type text using ADB Keyboard.
+* Automatically saves and restores the original keyboard.
+*/
+async function typeText(text, deviceId) {
+	const originalIme = await detectAndSetAdbKeyboard(deviceId);
+	try {
+		await clearText(deviceId);
+		await runAdbCommand(deviceId, [
+			"shell",
+			"am",
+			"broadcast",
+			"-a",
+			"ADB_INPUT_B64",
+			"--es",
+			"msg",
+			Buffer.from(text, "utf8").toString("base64")
+		]);
+		await sleep(300);
+	} finally {
+		await restoreKeyboard(originalIme, deviceId);
+	}
+}
+/**
+* Clear text by sending backspace keystrokes.
+*/
+async function clearText(deviceId) {
+	await runAdbCommand(deviceId, [
+		"shell",
+		"am",
+		"broadcast",
+		"-a",
+		"ADB_CLEAR_TEXT"
+	]);
+	await sleep(300);
+}
+
+//#endregion
+//#region src/actions/handler.ts
+/**
+* Create a finish action.
+*/
+function finish(message) {
+	return {
+		_metadata: "finish",
+		message
+	};
+}
+/**
+* Action handler that executes the actions on the device.
+*/
+var ActionHandler = class {
+	constructor(context, callbacks = {}) {
+		this.context = context;
+		this.callbacks = callbacks;
+	}
+	get deviceId() {
+		return this.context.getConfig().deviceId;
+	}
+	/**
+	* Execute an action.
+	*/
+	async execute(action, screenWidth, screenHeight) {
+		try {
+			if (action._metadata === "finish") return {
+				success: true,
+				should_finish: true,
+				message: action.message
+			};
+			switch (action.action) {
+				case "Launch": return await this.executeLaunchAction(action);
+				case "Tap": return await this.executeTapAction(action, screenWidth, screenHeight);
+				case "Type": return await this.executeTypeAction(action);
+				case "Swipe": return await this.executeSwipeAction(action, screenWidth, screenHeight);
+				case "Back": return await this.executeBackAction(action);
+				case "Home": return await this.executeHomeAction(action);
+				case "Long Press": return await this.executeLongPressAction(action, screenWidth, screenHeight);
+				case "Double Tap": return await this.executeDoubleTapAction(action, screenWidth, screenHeight);
+				case "Wait": return await this.executeWaitAction(action);
+				case "Take_over": return await this.executeTakeOverAction(action);
+				default: return {
+					success: false,
+					should_finish: true,
+					message: `Unknown action: ${action.action}`
+				};
+			}
+		} catch (error) {
+			return {
+				success: false,
+				should_finish: true,
+				message: `Action execution failed: ${error instanceof Error ? error.message : "Unknown error"}`
+			};
+		}
+	}
+	/**
+	* Execute launch action.
+	*/
+	async executeLaunchAction(action) {
+		if (!await launchApp(action.app, this.deviceId)) return {
+			success: false,
+			should_finish: false,
+			message: `Failed to launch app: ${action.app}`
+		};
+		return {
+			success: true,
+			should_finish: false
+		};
+	}
+	convertRelativeToAbsolute(element, screenWidth, screenHeight) {
+		return [element[0] / 1e3 * screenWidth, element[1] / 1e3 * screenHeight];
+	}
+	/**
+	* Execute tap action.
+	*/
+	async executeTapAction(action, screenWidth, screenHeight) {
+		const [x, y] = action.element;
+		const [absoluteX, absoluteY] = this.convertRelativeToAbsolute([x, y], screenWidth, screenHeight);
+		await tap(absoluteX, absoluteY, this.deviceId);
+		return {
+			success: true,
+			should_finish: false
+		};
+	}
+	/**
+	* Execute type action.
+	*/
+	async executeTypeAction(action) {
+		await typeText(action.text, this.deviceId);
+		return {
+			success: true,
+			should_finish: false
+		};
+	}
+	/**
+	* Execute swipe action.
+	*/
+	async executeSwipeAction(action, screenWidth, screenHeight) {
+		const [startX, startY] = this.convertRelativeToAbsolute(action.start, screenWidth, screenHeight);
+		const [endX, endY] = this.convertRelativeToAbsolute(action.end, screenWidth, screenHeight);
+		await swipe(startX, startY, endX, endY, action.duration, this.deviceId);
+		return {
+			success: true,
+			should_finish: false
+		};
+	}
+	/**
+	* Execute back action.
+	*/
+	async executeBackAction(_action) {
+		await back(this.deviceId);
+		return {
+			success: true,
+			should_finish: false
+		};
+	}
+	/**
+	* Execute home action.
+	*/
+	async executeHomeAction(_action) {
+		await home(this.deviceId);
+		return {
+			success: true,
+			should_finish: false
+		};
+	}
+	/**
+	* Execute long press action.
+	*/
+	async executeLongPressAction(action, screenWidth, screenHeight) {
+		const [x, y] = this.convertRelativeToAbsolute(action.element, screenWidth, screenHeight);
+		await longPress(x, y, action.duration, this.deviceId);
+		return {
+			success: true,
+			should_finish: false
+		};
+	}
+	/**
+	* Execute double tap action.
+	*/
+	async executeDoubleTapAction(action, screenWidth, screenHeight) {
+		const [x, y] = this.convertRelativeToAbsolute(action.element, screenWidth, screenHeight);
+		await doubleTap(x, y, this.deviceId);
+		return {
+			success: true,
+			should_finish: false
+		};
+	}
+	/**
+	* Execute wait action.
+	*/
+	async executeWaitAction(action) {
+		const duration = action.duration || 1;
+		await new Promise((resolve) => setTimeout(resolve, duration * 1e3));
+		return {
+			success: true,
+			should_finish: false
+		};
+	}
+	/**
+	* Execute take over action.
+	*/
+	async executeTakeOverAction(action) {
+		if (this.callbacks.takeoverCallback) {
+			await this.callbacks.takeoverCallback(action.reason || "Manual takeover requested");
+			return {
+				success: true,
+				should_finish: false
+			};
+		}
+		return {
+			success: false,
+			should_finish: true,
+			message: `Takeover requested but no callback provided: ${action.reason}`
+		};
+	}
+};
+
+//#endregion
+//#region src/actions/parse.ts
+function getElements(node, index = 1) {
+	if (node.type !== "SequenceExpression") return;
+	return node.expressions[index].right.elements.map((e) => e.value);
+}
+function getText(node) {
+	if (node.type !== "SequenceExpression") return;
+	return node.expressions[1].right.value;
+}
+function getActionType(node) {
+	if (node.type === "SequenceExpression") return node.expressions[0].right.value;
+	if (node.type === "AssignmentExpression") return node.right.value;
+}
+/**
+* Parse action from string format.
+*/
+function parseAction(actionStr) {
+	if (actionStr.startsWith("finish(")) {
+		const match = actionStr.match(/finish\(message=(.*)\)/);
+		return {
+			_metadata: "finish",
+			message: match ? match[1].trim() : void 0
+		};
+	}
+	if (actionStr.startsWith("do(")) {
+		const ast = parse(actionStr, { ecmaVersion: "latest" });
+		if (ast.body[0].type !== "DoWhileStatement") throw new Error(`Invalid action format: ${actionStr}`);
+		const expression = ast.body[0].body.expression;
+		const actionType = getActionType(expression);
+		if (actionType === "Launch") {
+			const app = getText(expression);
+			if (!app) throw new Error(`Invalid Launch action parameters: ${actionStr}`);
+			return {
+				_metadata: "do",
+				action: "Launch",
+				app
+			};
+		}
+		if (actionType === "Tap") {
+			const element = getElements(expression);
+			if (!element) throw new Error(`Invalid Tap action parameters: ${actionStr}`);
+			return {
+				_metadata: "do",
+				action: "Tap",
+				element
+			};
+		}
+		if (actionType === "Type") {
+			const text = getText(expression);
+			if (!text) throw new Error(`Invalid Type action parameters: ${actionStr}`);
+			return {
+				_metadata: "do",
+				action: "Type",
+				text: text.trim()
+			};
+		}
+		if (actionType === "Swipe") {
+			const start = getElements(expression, 1);
+			const end = getElements(expression, 2);
+			if (!start || !end) throw new Error(`Invalid Swipe action parameters: ${actionStr}`);
+			return {
+				_metadata: "do",
+				action: "Swipe",
+				start,
+				end
+			};
+		}
+		if (actionType === "Back") return {
+			_metadata: "do",
+			action: "Back"
+		};
+		if (actionType === "Home") return {
+			_metadata: "do",
+			action: "Home"
+		};
+		if (actionType === "Long Press") {
+			const element = getElements(expression);
+			if (!element) throw new Error(`Invalid Long Press action parameters: ${actionStr}`);
+			return {
+				_metadata: "do",
+				action: "Long Press",
+				element
+			};
+		}
+		if (actionType === "Double Tap") {
+			const element = getElements(expression);
+			if (!element) throw new Error(`Invalid Double Tap action parameters: ${actionStr}`);
+			return {
+				_metadata: "do",
+				action: "Double Tap",
+				element
+			};
+		}
+		if (actionType === "Wait") {
+			const duration = getText(expression);
+			if (!duration) throw new Error(`Invalid Wait action parameters: ${actionStr}`);
+			return {
+				_metadata: "do",
+				action: "Wait",
+				duration: Number.parseInt(duration, 10)
+			};
+		}
+		if (actionType === "Take_over") {
+			const reason = getText(expression);
+			if (!reason) throw new Error(`Invalid Take_over action parameters: ${actionStr}`);
+			return {
+				_metadata: "do",
+				action: "Take_over",
+				reason
+			};
+		}
+	}
+	throw new Error(`Unknown action format: ${actionStr}`);
+}
+
+//#endregion
+//#region src/adb/types.ts
+/**
+* Screenshot data.
+*/
+var Screenshot = class {
+	constructor(base64Data, width, height) {
+		this.base64Data = base64Data;
+		this.width = width;
+		this.height = height;
+	}
+};
+
+//#endregion
+//#region src/adb/screenshot.ts
+/**
+* Take a screenshot and return it as a base64 encoded string.
+* Similar to the Python version, saves to temp file first then converts to base64.
+*/
+async function getScreenshot(deviceId, timeout = 10, quality = 80) {
+	const tempPath = join(tmpdir(), `screenshot_${randomUUID()}.png`);
+	try {
+		const dimensionMatch = (await runAdbCommand(deviceId, [
+			"shell",
+			"wm",
+			"size"
+		])).stdout.match(/Physical size: (\d+)x(\d+)/);
+		if (!dimensionMatch) throw new Error("Failed to get screen dimensions");
+		const width = Number.parseInt(dimensionMatch[1], 10);
+		const height = Number.parseInt(dimensionMatch[2], 10);
+		const screenshotResult = await runAdbCommand(deviceId, [
+			"shell",
+			"screencap",
+			"-p",
+			"/sdcard/tmp_screenshot.png"
+		], timeout * 1e3);
+		const output = screenshotResult.stdout + screenshotResult.stderr;
+		if (output.includes("Status: -1") || output.includes("Failed")) return createFallbackScreenshot(true);
+		await runAdbCommand(deviceId, [
+			"pull",
+			"/sdcard/tmp_screenshot.png",
+			tempPath
+		], timeout * 5e3);
+		const base64Data = (await sharp(tempPath).resize({
+			width: 480,
+			withoutEnlargement: true,
+			fastShrinkOnLoad: true
+		}).webp({
+			lossless: false,
+			quality,
+			effort: 6
+		}).toBuffer()).toString("base64");
+		await unlink(tempPath).catch(() => {});
+		await runAdbCommand(deviceId, [
+			"shell",
+			"rm",
+			"/sdcard/tmp_screenshot.png"
+		]);
+		return new Screenshot(base64Data, width, height);
+	} catch (error) {
+		console.error(`Screenshot error: ${error}`);
+		try {
+			await unlink(tempPath);
+		} catch {}
+		return createFallbackScreenshot(false);
+	}
+}
+/**
+* Create a black fallback image when screenshot fails.
+*/
+function createFallbackScreenshot(_isSensitive) {
+	return new Screenshot("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==", 1080, 2400);
+}
+
+//#endregion
+//#region src/context/config.ts
+/**
+* Get the system prompt based on the language.
+*/
+function getSystemPrompt(lang) {
+	return lang === "cn" ? SYSTEM_PROMPT_ZH : SYSTEM_PROMPT_EN;
+}
+/**
+* Configuration for the model.
+*/
+var AgentConfigStore = class {
+	config = {
+		maxSteps: 100,
+		lang: "cn",
+		baseUrl: "http://localhost:8000/v1",
+		apiKey: "",
+		systemPrompt: void 0,
+		model: "autoglm-phone",
+		maxTokens: 3e3,
+		temperature: 0,
+		topP: .85,
+		frequencyPenalty: .2,
+		screenshotQuality: 80
+	};
+	ensureSystemPrompt() {
+		if (!this.config.systemPrompt) this.config.systemPrompt = getSystemPrompt(this.config.lang);
+	}
+	constructor(initialConfig) {
+		if (initialConfig) this.setConfig(initialConfig);
+		this.ensureSystemPrompt();
+	}
+	setConfig(config) {
+		this.config = {
+			...this.config,
+			...config
+		};
+		this.ensureSystemPrompt();
+	}
+	getConfig() {
+		return this.config;
+	}
+};
+function createAgentConfigStore(config) {
+	return new AgentConfigStore(config);
+}
+
+//#endregion
+//#region src/context/event.ts
+let EventType = /* @__PURE__ */ function(EventType$1) {
+	EventType$1["START"] = "start";
+	EventType$1["THINKING"] = "thinking";
+	EventType$1["ACTION"] = "action";
+	EventType$1["TASK_COMPLETE"] = "task_complete";
+	EventType$1["ERROR"] = "error";
+	EventType$1["ABORTED"] = "aborted";
+	EventType$1["THINKING_STREAM"] = "thinking_stream";
+	return EventType$1;
+}({});
+function createEmitter() {
+	return mitt();
+}
+
+//#endregion
+//#region src/context/index.ts
+var AgentContext = class {
+	configStore;
+	emitter;
 	constructor(config) {
-		config && setAgentConfig({
-			...config,
-			mode: "api"
+		this.configStore = createAgentConfigStore(config);
+		this.emitter = createEmitter();
+	}
+	getConfig() {
+		return this.configStore.getConfig();
+	}
+	updateConfig(config) {
+		this.configStore.setConfig(config);
+	}
+	emit(event, data) {
+		this.emitter.emit(event, {
+			message: data,
+			time: dayjs().format("hh:mm:ss A")
 		});
-		this.phoneAgent = new PhoneAgent();
 	}
-	static async createAgent(config) {
-		setAgentConfig({
-			...config,
-			mode: "api"
+	on(event, handler) {
+		return this.emitter.on(event, handler);
+	}
+	off(event, handler) {
+		return this.emitter.off(event, handler);
+	}
+};
+
+//#endregion
+//#region src/model/client.ts
+/**
+* Helper class for building conversation messages.
+*/
+var MessageBuilder = class {
+	/**
+	* Create a system message.
+	*/
+	static createSystemMessage(content) {
+		return {
+			role: "system",
+			content
+		};
+	}
+	/**
+	* Create a user message with optional image.
+	*/
+	static createUserMessage(text, imageBase64) {
+		const content = [];
+		if (imageBase64) content.push({
+			type: "image_url",
+			image_url: { url: `data:image/png;base64,${imageBase64}` }
 		});
-		const instance = new AutoGLM();
-		await checkSystemRequirements();
-		await checkModelApi();
-		return instance;
+		content.push({
+			type: "text",
+			text
+		});
+		return {
+			role: "user",
+			content
+		};
 	}
-	run(task) {
-		this.phoneAgent.run(task);
-		return emitter;
+	/**
+	* Create an assistant message.
+	*/
+	static createAssistantMessage(content) {
+		return {
+			role: "assistant",
+			content
+		};
 	}
-	checkModelApi() {
-		return checkModelApi();
+	/**
+	* Remove image content from a message to save context space.
+	*/
+	static removeImagesFromMessage(message) {
+		if (Array.isArray(message.content)) message.content = message.content.filter((item) => "type" in item && item.type === "text");
+		return message;
+	}
+	/**
+	* Build screen info string for the model.
+	*/
+	static buildScreenInfo(currentApp, extraInfo) {
+		const info = {
+			current_app: currentApp,
+			...extraInfo
+		};
+		return JSON.stringify(info, null, 2);
+	}
+};
+/**
+* Client for interacting with OpenAI-compatible vision-language models.
+*/
+var ModelClient = class {
+	ctx;
+	client;
+	constructor(ctx) {
+		this.ctx = ctx;
+		this.client = new OpenAI({
+			baseURL: ctx.getConfig().baseUrl,
+			apiKey: ctx.getConfig().apiKey
+		});
+	}
+	get config() {
+		return this.ctx.getConfig();
+	}
+	/**
+	* Send a request to the model with streaming support.
+	*/
+	async request(messages, options) {
+		const stream = await this.client.chat.completions.create({
+			messages,
+			model: this.config.model,
+			max_tokens: this.config.maxTokens,
+			temperature: this.config.temperature,
+			top_p: this.config.topP,
+			frequency_penalty: this.config.frequencyPenalty,
+			stream: true
+		}, { signal: options?.signal });
+		let rawContent = "";
+		let buffer = "";
+		const actionMarkers = ["finish(message=", "do(action="];
+		let inActionPhase = false;
+		for await (const chunk of stream) {
+			if (chunk.choices.length === 0) continue;
+			const content = chunk.choices[0].delta.content;
+			if (content) {
+				rawContent += content;
+				if (inActionPhase) continue;
+				buffer += content;
+				let markerFound = false;
+				for (const marker of actionMarkers) if (buffer.includes(marker)) {
+					const thinkingPart = buffer.split(marker, 1)[0];
+					this.ctx.emit(EventType.THINKING_STREAM, thinkingPart);
+					inActionPhase = true;
+					markerFound = true;
+					break;
+				}
+				if (markerFound) continue;
+				let isPotentialMarker = false;
+				for (const marker of actionMarkers) {
+					for (let i = 1; i < marker.length; i++) if (buffer.endsWith(marker.slice(0, i))) {
+						isPotentialMarker = true;
+						break;
+					}
+					if (isPotentialMarker) break;
+				}
+				if (!isPotentialMarker) {
+					this.ctx.emit(EventType.THINKING_STREAM, buffer);
+					buffer = "";
+				}
+			}
+		}
+		const [thinking, action] = this._parseResponse(rawContent);
+		this.ctx.emit(EventType.THINKING, thinking);
+		return {
+			thinking,
+			action,
+			rawContent
+		};
+	}
+	/**
+	* Parse the model response into thinking and action parts.
+	*/
+	_parseResponse(content) {
+		if (content.includes("finish(message=")) {
+			const parts = content.split("finish(message=");
+			return [parts[0].trim(), `finish(message=${parts[1]}`];
+		}
+		if (content.includes("do(action=")) {
+			const parts = content.split("do(action=");
+			return [parts[0].trim(), `do(action=${parts[1]}`];
+		}
+		if (content.includes("<answer>")) {
+			const parts = content.split("<answer>");
+			return [parts[0].replace("<think>", "").replace("</think>", "").trim(), parts[1].replace("</answer>", "").trim()];
+		}
+		return ["", content];
+	}
+};
+
+//#endregion
+//#region src/agent/index.ts
+var PhoneAgent = class {
+	ctx;
+	modelClient;
+	actionHandler;
+	context = [];
+	stepCount = 0;
+	abortController = null;
+	isAborted = false;
+	constructor(context, confirmationCallback, takeoverCallback) {
+		this.ctx = context;
+		this.modelClient = new ModelClient(context);
+		this.actionHandler = new ActionHandler(context, {
+			confirmationCallback,
+			takeoverCallback
+		});
+	}
+	get agentConfig() {
+		return this.ctx.getConfig();
+	}
+	abort(reason = "User aborted") {
+		if (!this.abortController) return;
+		this.abortController.abort(reason);
+		this.isAborted = true;
+		this.ctx.emit(EventType.ABORTED, reason);
+	}
+	checkAborted() {
+		if (this.isAborted && this.abortController?.signal.aborted) return false;
+		return true;
+	}
+	/**
+	* Run the agent to complete a task.
+	*/
+	async run(task, signal) {
+		if (this.abortController) {
+			this.abortController.abort();
+			this.abortController = null;
+		}
+		this.abortController = new AbortController();
+		this.isAborted = false;
+		if (signal) signal.addEventListener("abort", () => {
+			this.abort(signal.reason || "External signal aborted");
+		});
+		try {
+			this.reset();
+			let result = await this._executeStep(task, true);
+			if (result.finished) return result.message || "Task completed";
+			while (this.stepCount < this.agentConfig.maxSteps) {
+				if (!this.checkAborted()) return "Agent aborted";
+				result = await this._executeStep(void 0, false);
+				if (result.finished) return result.message || "Task completed";
+			}
+			throw new Error("Max steps reached");
+		} finally {
+			this.abortController = null;
+		}
+	}
+	/**
+	* Execute a single step of the agent.
+	* Useful for manual control or debugging.
+	*/
+	async step(task) {
+		const isFirst = this.context.length === 0;
+		if (isFirst && !task) throw new Error("Task is required for the first step");
+		return this._executeStep(task, isFirst);
+	}
+	/**
+	* Reset the agent state for a new task.
+	*/
+	reset() {
+		this.context = [];
+		this.stepCount = 0;
+	}
+	/**
+	* Get the current conversation context.
+	*/
+	getContext() {
+		return [...this.context];
+	}
+	/**
+	* Get the current step count.
+	*/
+	getStepCount() {
+		return this.stepCount;
+	}
+	/**
+	* Execute a single step of the agent loop.
+	*/
+	async _executeStep(task, isFirst = false) {
+		this.stepCount++;
+		const screenshot = await getScreenshot(this.agentConfig.deviceId, 10, this.agentConfig.screenshotQuality);
+		const currentApp = await getCurrentApp(this.agentConfig.deviceId);
+		if (isFirst) {
+			this.context.push(MessageBuilder.createSystemMessage(this.agentConfig.systemPrompt));
+			const textContent = `${task}\n\n${MessageBuilder.buildScreenInfo(currentApp)}`;
+			this.context.push(MessageBuilder.createUserMessage(textContent, screenshot.base64Data));
+		} else {
+			const textContent = `** Screen Info **\n\n${MessageBuilder.buildScreenInfo(currentApp)}`;
+			this.context.push(MessageBuilder.createUserMessage(textContent, screenshot.base64Data));
+		}
+		try {
+			const response = await this.modelClient.request(this.context, { signal: this.abortController?.signal });
+			let action;
+			try {
+				action = parseAction(response.action);
+			} catch {
+				action = finish(response.action);
+			}
+			this.ctx.emit(EventType.ACTION, action);
+			this.context[this.context.length - 1] = MessageBuilder.removeImagesFromMessage(this.context[this.context.length - 1]);
+			const result = await this.actionHandler.execute(action, screenshot.width, screenshot.height);
+			this.context.push(MessageBuilder.createAssistantMessage(`<think>${response.thinking}</think><answer>${response.action}</answer>`));
+			const finished = action._metadata === "finish" || result.should_finish;
+			if (finished) {
+				const actionMessage$1 = action._metadata === "finish" ? action.message : void 0;
+				const message = result.message || actionMessage$1 || "Task completed";
+				this.ctx.emit(EventType.TASK_COMPLETE, message);
+			}
+			const actionMessage = action._metadata === "finish" ? action.message : void 0;
+			return {
+				success: result.success,
+				finished,
+				action,
+				thinking: response.thinking,
+				message: result.message || actionMessage
+			};
+		} catch (error) {
+			return {
+				success: false,
+				finished: true,
+				action: null,
+				thinking: "",
+				message: `Model error: ${error instanceof Error ? error.message : "Unknown error"}`
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/check/index.ts
+async function checkSystemRequirements(ctx) {
+	/**
+	* check adb connection
+	*/
+	const conn = new ADBConnection();
+	const key = new ADBKeyboard(ctx);
+	try {
+		if (!(await conn.version()).success) return {
+			success: false,
+			code: ErrorCode.ADB_NOT_INSTALLED
+		};
+		if (!(await conn.devices()).success) return {
+			success: false,
+			code: ErrorCode.ADB_DEVICE_UNCONNECTED
+		};
+		if (!(await key.isKeyboardInstalled()).success) return {
+			success: false,
+			code: ErrorCode.ADB_KEYBOARD_UNINSTALLED
+		};
+		return { success: true };
+	} catch (error) {
+		return {
+			success: false,
+			message: getErrorMessage(error),
+			code: ErrorCode.UNKNOWN_ERROR
+		};
+	}
+}
+async function checkModelApi(ctx) {
+	const config = ctx.getConfig();
+	try {
+		const response = await new OpenAI({
+			baseURL: config.baseUrl,
+			apiKey: config.apiKey
+		}).chat.completions.create({
+			model: config.model,
+			messages: [{
+				role: "user",
+				content: "hi"
+			}],
+			max_tokens: 5,
+			temperature: 0,
+			stream: false
+		});
+		if (!(response.choices && response.choices.length > 0)) return {
+			success: false,
+			code: ErrorCode.MODEL_API_CHECK_FAILED
+		};
+		return { success: true };
+	} catch (error) {
+		return {
+			success: false,
+			message: getErrorMessage(error),
+			code: ErrorCode.UNKNOWN_ERROR
+		};
+	}
+}
+
+//#endregion
+//#region src/autoglm.ts
+var AutoGLM = class {
+	phoneAgent;
+	ctx;
+	adbManager;
+	constructor(config) {
+		this.ctx = new AgentContext(config);
+		this.phoneAgent = new PhoneAgent(this.ctx);
+		this.adbManager = new ADBManager(this.ctx);
+	}
+	get adb() {
+		return this.adbManager;
+	}
+	abort(reason) {
+		this.phoneAgent.abort(reason);
 	}
 	checkSystemRequirements() {
-		return checkSystemRequirements();
+		return checkSystemRequirements(this.ctx);
+	}
+	checkModelApi() {
+		return checkModelApi(this.ctx);
+	}
+	run(task) {
+		this.ctx.emit(EventType.START, task);
+		return this.phoneAgent.run(task);
+	}
+	on(type, handler) {
+		this.ctx.on(type, handler);
+		return this;
+	}
+	off(type, handler) {
+		this.ctx.off(type, handler);
+		return this;
+	}
+	get config() {
+		return this.ctx.getConfig();
+	}
+	updateConfig(config) {
+		this.ctx.updateConfig(config);
 	}
 };
 
 //#endregion
-export { AutoGLM };
+export { APP_PACKAGES, AUTOGLM_FILEPATH, AutoGLM, ErrorCode, EventType, SYSTEM_PROMPT_EN, SYSTEM_PROMPT_ZH, Screenshot, listSupportedApps, runAdbCommand };