@windypro-rourou/dsh-logcat 0.2.9 → 0.3.0

package/README.md

@@ -14,23 +14,25 @@ DSH Web GUI 的安卓实机调试面板（类似 Android Studio 的 Logcat 视
   - 级别过滤（V/D/I/W/E/F 单选，颜色与 Android Studio 一致）
   - 关键词过滤、**测试包名输入框**（回车设置，与 agent 的 `logcat_set_package` 互通，状态栏实时显示）
   - **截图按钮**：一键截取真机屏幕并下载 PNG（`exec-out screencap`）
+  - **崩溃高亮**：FATAL EXCEPTION / ANR 行红色高亮，一眼定位崩溃
   - 暂停/继续（暂停时缓冲，恢复自动回放）、清空、复制、导出 .txt
   - 窗口化渲染 + 自动滚动（滚动手动上翻时自动停用）
   - 未授权设备提示「请在手机上点击允许 USB 调试」
-- **Agent 工具**：
-  - `logcat_devices`：列出已连接设备（serial / model / state），判断能否实机调试。
-  - `adb_exec`：在指定设备执行 `adb shell` 命令（启动 Activity、查进程、dump UI 等），
-    破坏性操作（卸载 / 重启 / 清数据）需先确认。
-  - `adb_install`：把**本地 APK 安装到真机**（`adb install -r <本地路径>`，构建产物直接部署）。
-  - `adb_pull`：从设备拉取文件到本地（截图 / 日志 / bugreport）。
-  - `logcat_set_package`：设置 / 清除当前测试的 app 包名（安装 / 启动应用后调用）。
-  - `logcat_recent`：读取某设备最近 N 条日志，支持级别 / 关键词过滤；
-    设置了测试包名（或显式传 `package`）时自动按该 app 的 pid 过滤日志。
+- **Agent 工具**（共 18 个，全部对 agent 开放，前置提示中已明示可调用）：
+  - 设备：`logcat_devices`（列出设备）、`device_info`（型号/版本/SDK/分辨率/内存/电量）、`device_stats`（CPU/内存/电量实时采样）
+  - 执行：`adb_exec`（shell）、`adb_install`（本地 APK 装真机）、`adb_pull`（拉文件）
+  - 输入：`input_tap` / `input_swipe` / `input_text`（真机 UI 自动化）、`ui_dump`（界面层级 XML）
+  - 日志：`logcat_recent`（按包名/级别/关键词过滤）、`logcat_crash`（崩溃/ANR 自动捕获 + 上下文）、
+    `logcat_set_package`（锁定当前测试包名）
+  - 逆向/内存：`proc_list`（进程列表）、`proc_maps`（内存映射 + so 模块基址）、`proc_status`（进程状态/内存摘要）、
+    `mem_dump`（指定地址读内存 hex）、`frida_server`（frida-server 部署/启停）
 - **实机调试工作流**：构建安卓应用时，agent 的通告会动态列出当前已连接设备（serial + 型号）与当前测试包名，
-  可先向用户确认后用 `adb_install` 部署 APK → `adb_exec` 启动 → `logcat_set_package` 锁定目标 app →
-  `logcat_recent` 按包名查看崩溃日志 → `adb_pull` 拉取截图 / 日志，闭环真机调试。
+  可先向用户确认后：`adb_install` 部署 APK → `adb_exec` 启动 → `logcat_set_package` 锁包 →
+  `logcat_recent` / `logcat_crash` 看崩溃 → `ui_dump` + `input_*` 做界面自动化 → `adb_pull` 取证，闭环真机调试。
+- **逆向工作流**：`proc_list` 定位进程 → `proc_maps` 拿模块基址/权限 → `mem_dump` 读目标地址 →
+  `frida_server` 起 frida 做动态插桩。读其他应用内存/maps 需要 root 或 debuggable 应用（run-as），工具会给出明确提示。
 - **附加能力**：`POST /api/dsh-logcat/exec` 执行 shell、`POST /api/dsh-logcat/package` 设置包名、
-  `GET /api/dsh-logcat/screenshot` 截屏。
+  `GET /api/dsh-logcat/screenshot` 截屏、`POST /api/dsh-logcat/install-adb` 一键装 adb。
 
 ## 安装
 

package/lib/client.js

@@ -71,6 +71,9 @@ window.__ModuleLoader__.load({
 .lc-line .lv.W { color: #fbc02d; } .lc-line .lv.E { color: #ef5350; } .lc-line .lv.F { color: #ab47bc; }
 .lc-line .tag { color: #29b6f6; margin-right: 8px; }
 .lc-line.cont .msg { padding-left: 44px; color: var(--lc-dim, #9e9e9e); }
+.lc-line.crash { background: rgba(239,83,80,.14); box-shadow: inset 2px 0 0 #ef5350; }
+.lc-line.crash .tag { color: #ef5350; font-weight: 700; }
+.lc-line.crash .msg { color: #ef5350; }
 .lc-empty { position: absolute; inset: 0; display: flex; align-items: center; justify-content: center; color: var(--lc-dim, #9e9e9e); font-size: 13px; }
 .lc-status { display: flex; align-items: center; gap: 14px; padding: 4px 12px; border-top: 1px solid rgba(128,128,128,.25); flex: none; font-size: 11px; color: var(--lc-dim, #9e9e9e); }
 .lc-status b { font-weight: 600; color: inherit; }
@@ -487,13 +490,14 @@ window.__ModuleLoader__.load({
 			}, [scrollTop, entries.length]);
 
 			const rows = [];
+			const isCrash = (e) => /FATAL EXCEPTION|ANR in /.test(e.raw) || (e.tag === "AndroidRuntime" && e.level === "F");
 			for (let i = viewport.top; i < viewport.bottom && i < entries.length; i++) {
 				const e = entries[i];
 				const level = e.level !== "" ? e.level : " ";
 				rows.push(
 					h("div", {
 						key: i,
-						className: "lc-line" + (e.cont === true ? " cont" : ""),
+						className: "lc-line" + (e.cont === true ? " cont" : "") + (isCrash(e) ? " crash" : ""),
 						style: { top: i * ROW },
 						title: e.raw,
 					},

package/lib/index.js

@@ -36,7 +36,17 @@ const SECTION_ORDER = 152
 
 /** Model-facing announcement: plugin presence, capabilities, and limits. */
 export const LOGCAT_GUIDANCE =
-  '本机已安装 dsh-logcat 插件（DSH Web GUI 的安卓实机调试面板）：侧边栏「Logcat」入口；自动探测本机 adb，对已连接的调试设备自动附加 logcat 流（threadtime，每设备 2000 行环形缓冲）；Web 面板支持设备切换、级别/关键词过滤、暂停/清空/导出；agent 工具：logcat_devices（列出已连接设备）、adb_exec（在设备上执行 adb shell：安装/启动/查看日志/截图等）、logcat_recent（读取最近日志）。构建安卓应用时若检测到已连接设备，可先向用户确认后用 adb_exec / logcat_recent 直接实机调试。限制：需设备开启 USB 调试并授权本机；logcat 输出可能含敏感信息；adb 命令消耗真实设备资源，破坏性操作（卸载/重启/清数据）先确认再执行。用户提到「Logcat / 安卓日志 / 实机调试 / adb 日志」时即指本插件，请据此协作。'
+  '本机已安装 dsh-logcat 插件（DSH Web GUI 的安卓实机调试/逆向工作台）：自动探测本机 adb 并对已连接的调试设备附加 logcat 流；侧边栏「Logcat」入口打开面板（设备切换、级别/关键词过滤、按测试包名过滤、截图、崩溃高亮、一键安装 adb）。' +
+  '以下 agent 工具均可用（串口为设备 serial，可用 logcat_devices 获取），构建安卓应用/实机调试/逆向分析时请主动调用：' +
+  '设备与状态：logcat_devices（列出设备）、device_info（型号/版本/SDK/分辨率/内存/电量）、device_stats（CPU/内存/电量采样）；' +
+  '部署与执行：adb_install（本地 APK 装真机）、adb_exec（任意 adb shell 命令）、adb_pull（拉文件）、input_tap/input_swipe/input_text（模拟点击/滑动/输入）、ui_dump（界面层级 XML）；' +
+  '日志与崩溃：logcat_recent（按级别/关键词/包名读日志）、logcat_crash（崩溃/ANR 捕获+上下文）、logcat_set_package（锁定当前测试包名）；' +
+  '逆向与内存：proc_list（进程列表）、proc_maps（内存映射+so 模块基址）、proc_status（进程状态/内存摘要）、mem_dump（指定地址读内存 hex）、frida_server（frida-server 部署/启停）。' +
+  '工作流建议：构建安卓应用 → 确认设备在线后 adb_install 部署、adb_exec 启动、logcat_set_package 锁包、logcat_recent/logcat_crash 看崩溃、ui_dump+input_* 做界面自动化；' +
+  '逆向分析 → proc_list 找进程、proc_maps 拿模块基址、mem_dump 读内存、frida_server 起 frida。' +
+  '限制：需设备开启 USB 调试并授权本机；读其他应用内存/maps 需要 root 或 debuggable 应用（run-as）；logcat 输出可能含敏感信息；' +
+  'adb 命令消耗真实设备资源，破坏性操作（卸载/重启/清数据/杀进程）先向用户确认再执行。' +
+  '用户提到「Logcat / 安卓日志 / 实机调试 / adb 日志 / 逆向 / 读内存 / 抓包定位」时即指本插件，请据此主动协作。'
 
 /** Dynamic model-facing announcement: base guidance plus currently attached devices. */
 function logcatGuidance(engine) {
@@ -911,6 +921,605 @@ function adbPullTool(engine) {
   })
 }
 
+/** The logcat_crash agent tool: find recent crash/ANR blocks with context. */
+function logcatCrashTool(engine) {
+  return defineTool({
+    name: 'logcat_crash',
+    description: 'Find recent Android crash/ANR blocks (FATAL EXCEPTION / ANR in / AndroidRuntime) in the buffered logcat, with surrounding context lines. ' +
+      'Triggers: check whether the app crashed, get the exception stack for a crash.',
+    parameters: {
+      serial: { type: 'string', description: 'Device serial from logcat_devices (optional; defaults to the first attached device).' },
+      lines: { type: 'integer', description: 'Scan window into the ring buffer (default 2000, max 2000).' },
+      context: { type: 'integer', description: 'Lines of context around each crash marker (default 8).' },
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          crashes: {
+            type: 'array',
+            required: true,
+            items: {
+              type: 'object',
+              additionalProperties: false,
+              properties: {
+                ts: { type: 'string', required: true },
+                pid: { type: 'integer', required: true },
+                tag: { type: 'string', required: true },
+                kind: { type: 'string', required: true },
+                summary: { type: 'string', required: true },
+                lines: { type: 'array', required: true, items: { type: 'string' } },
+              },
+            },
+          },
+        },
+      },
+      render: (_args, value) => {
+        const crashes = value?.crashes ?? []
+        if (crashes.length === 0) return [{ type: 'text', text: '(no crash / ANR found in the scanned window)' }]
+        const blocks = crashes.map((c) => `${c.ts} [${c.kind}] pid=${c.pid} ${c.tag}\n  ${c.summary}\n  ` + c.lines.join('\n  '))
+        return [{ type: 'text', text: blocks.join('\n\n') }]
+      },
+    },
+    async execute(args) {
+      const devices = engine.deviceList()
+      const serial = typeof args.serial === 'string' && args.serial !== '' ? args.serial : devices[0]?.serial ?? ''
+      if (serial === '') return { crashes: [] }
+      const scan = Math.min(Math.max(Number(args.lines ?? 2000) || 2000, 1), 2000)
+      const context = Math.min(Math.max(Number(args.context ?? 8) || 8, 0), 40)
+      const entries = engine.recent(serial, scan)
+      const MARKER = /FATAL EXCEPTION|ANR in |AndroidRuntime:/
+      const crashes = []
+      for (let i = 0; i < entries.length; i++) {
+        const e = entries[i]
+        if (!MARKER.test(e.raw)) continue
+        const start = Math.max(0, i - context)
+        const end = Math.min(entries.length, i + context + 1)
+        const block = entries.slice(start, end)
+        const first = block.find((b) => /FATAL EXCEPTION|ANR in /.test(b.raw)) ?? e
+        crashes.push({
+          ts: first.ts,
+          pid: first.pid,
+          tag: first.tag,
+          kind: /ANR in /.test(first.raw) ? 'ANR' : 'FATAL',
+          summary: first.msg.slice(0, 240),
+          lines: block.map((b) => b.raw),
+        })
+        i = end - 1
+      }
+      return { crashes }
+    },
+  })
+}
+
+/** The device_info agent tool: structured device facts. */
+function deviceInfoTool(engine) {
+  return defineTool({
+    name: 'device_info',
+    description: 'Get structured info about an attached Android device (model, brand, Android version, SDK, resolution, ABI, total memory, battery) — ' +
+      'for environment/version checks before debugging.',
+    parameters: {
+      serial: { type: 'string', description: 'Device serial from logcat_devices (optional; defaults to the first attached device).' },
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          serial: { type: 'string', required: true },
+          model: { type: 'string' },
+          brand: { type: 'string' },
+          androidVersion: { type: 'string' },
+          sdk: { type: 'string' },
+          resolution: { type: 'string' },
+          abi: { type: 'string' },
+          totalMemKb: { type: 'integer' },
+          batteryLevel: { type: 'integer' },
+          batteryStatus: { type: 'string' },
+        },
+      },
+      render: (_args, value) => {
+        const rows = ['model', 'brand', 'androidVersion', 'sdk', 'resolution', 'abi', 'totalMemKb', 'batteryLevel', 'batteryStatus']
+          .filter((k) => value?.[k] !== undefined && value[k] !== '')
+          .map((k) => `${k}: ${value[k]}`)
+        return [{ type: 'text', text: rows.length > 0 ? rows.join('\n') : '(no device)' }]
+      },
+    },
+    async execute(args) {
+      const devices = engine.deviceList()
+      const serial = typeof args.serial === 'string' && args.serial !== '' ? args.serial : devices[0]?.serial ?? ''
+      if (serial === '' || engine.adb === null) return { serial: '' }
+      const sh = 'getprop ro.product.model; getprop ro.product.brand; getprop ro.build.version.release; getprop ro.build.version.sdk; getprop ro.product.cpu.abi; wm size; grep MemTotal /proc/meminfo; dumpsys battery | grep -E "level:|status:"'
+      const result = await runAdbFull(engine.adb, ['-s', serial, 'shell', sh], 20000)
+      const lines = (result.stdout ?? '').split(/\r?\n/).map((s) => s.trim()).filter(Boolean)
+      const get = (i) => lines[i] ?? ''
+      const memMatch = /MemTotal:\s*(\d+) kB/.exec(lines.find((l) => l.startsWith('MemTotal')) ?? '')
+      const levelMatch = /level:\s*(\d+)/.exec(lines.find((l) => l.startsWith('level')) ?? '')
+      const statusMatch = /status:\s*(\S+)/.exec(lines.find((l) => l.startsWith('status')) ?? '')
+      return {
+        serial,
+        model: get(0) || undefined,
+        brand: get(1) || undefined,
+        androidVersion: get(2) || undefined,
+        sdk: get(3) || undefined,
+        abi: get(4) || undefined,
+        resolution: (lines.find((l) => l.startsWith('Physical size')) ?? '').replace('Physical size: ', '') || undefined,
+        totalMemKb: memMatch ? Number.parseInt(memMatch[1], 10) : undefined,
+        batteryLevel: levelMatch ? Number.parseInt(levelMatch[1], 10) : undefined,
+        batteryStatus: statusMatch?.[1] || undefined,
+      }
+    },
+  })
+}
+
+/** The device_stats agent tool: one-shot CPU / memory / battery sample. */
+function deviceStatsTool(engine) {
+  return defineTool({
+    name: 'device_stats',
+    description: 'Take a one-shot sample of device CPU / memory / battery state — for performance and resource checks while debugging an app.',
+    parameters: {
+      serial: { type: 'string', description: 'Device serial from logcat_devices (optional; defaults to the first attached device).' },
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          cpu: { type: 'string' },
+          memTotalKb: { type: 'integer' },
+          memFreeKb: { type: 'integer' },
+          batteryLevel: { type: 'integer' },
+          batteryStatus: { type: 'string' },
+        },
+      },
+      render: (_args, value) => {
+        const rows = ['cpu', 'memTotalKb', 'memFreeKb', 'batteryLevel', 'batteryStatus']
+          .filter((k) => value?.[k] !== undefined && value[k] !== '')
+          .map((k) => `${k}: ${value[k]}`)
+        return [{ type: 'text', text: rows.length > 0 ? rows.join('\n') : '(no device)' }]
+      },
+    },
+    async execute(args) {
+      const devices = engine.deviceList()
+      const serial = typeof args.serial === 'string' && args.serial !== '' ? args.serial : devices[0]?.serial ?? ''
+      if (serial === '' || engine.adb === null) return {}
+      const sh = 'top -b -n 1 | head -4; grep -E "MemTotal|MemFree" /proc/meminfo; dumpsys battery | grep -E "level:|status:"'
+      const result = await runAdbFull(engine.adb, ['-s', serial, 'shell', sh], 20000)
+      const lines = (result.stdout ?? '').split(/\r?\n/).map((s) => s.trim()).filter(Boolean)
+      const cpu = lines.find((l) => /%cpu|Cpu\(s\)|CPU:/i.test(l)) ?? undefined
+      const totalMatch = /MemTotal:\s*(\d+) kB/.exec(lines.find((l) => l.startsWith('MemTotal')) ?? '')
+      const freeMatch = /MemFree:\s*(\d+) kB/.exec(lines.find((l) => l.startsWith('MemFree')) ?? '')
+      const levelMatch = /level:\s*(\d+)/.exec(lines.find((l) => l.startsWith('level')) ?? '')
+      const statusMatch = /status:\s*(\S+)/.exec(lines.find((l) => l.startsWith('status')) ?? '')
+      return {
+        cpu,
+        memTotalKb: totalMatch ? Number.parseInt(totalMatch[1], 10) : undefined,
+        memFreeKb: freeMatch ? Number.parseInt(freeMatch[1], 10) : undefined,
+        batteryLevel: levelMatch ? Number.parseInt(levelMatch[1], 10) : undefined,
+        batteryStatus: statusMatch?.[1] || undefined,
+      }
+    },
+  })
+}
+
+/** Shared runner for `adb shell input ...` commands. */
+function inputShellTool(engine, name, description, argSpec, buildCommand) {
+  return defineTool({
+    name,
+    description,
+    parameters: {
+      serial: { type: 'string', description: 'Device serial from logcat_devices (optional; defaults to the first attached device).' },
+      ...argSpec,
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          ok: { type: 'boolean', required: true },
+          code: { type: 'integer' },
+          stdout: { type: 'string', required: true },
+          stderr: { type: 'string', required: true },
+        },
+      },
+      render: (_args, value) => {
+        const out = value?.stdout ?? ''
+        const err = value?.stderr ?? ''
+        const parts = []
+        if (out !== '') parts.push(out.trimEnd())
+        if (err !== '') parts.push('stderr: ' + err.trimEnd())
+        if (parts.length === 0) parts.push(value?.ok ? 'done' : `input failed (exit ${value?.code ?? '?'})`)
+        return [{ type: 'text', text: parts.join('\n') }]
+      },
+    },
+    async execute(args) {
+      const devices = engine.deviceList()
+      const serial = typeof args.serial === 'string' && args.serial !== ''
+        ? args.serial
+        : devices.find((d) => d.state === 'device')?.serial ?? ''
+      if (engine.adb === null) return { ok: false, code: null, stdout: '', stderr: 'adb not found on this host' }
+      if (serial === '') return { ok: false, code: null, stdout: '', stderr: 'no attached device; connect and authorize one first' }
+      const result = await runAdbFull(engine.adb, ['-s', serial, 'shell', buildCommand(args)], 15000)
+      return { ok: result.ok, code: result.code, stdout: result.stdout, stderr: result.stderr }
+    },
+  })
+}
+
+/** The input_tap agent tool: simulate a tap. */
+function inputTapTool(engine) {
+  return inputShellTool(engine, 'input_tap',
+    'Simulate a tap on the device screen at (x, y) — for UI automation flows. Combine with ui_dump to find element coordinates.',
+    { x: { type: 'integer', description: 'X coordinate (pixels).' }, y: { type: 'integer', description: 'Y coordinate (pixels).' } },
+    (a) => `input tap ${Number(a.x) | 0} ${Number(a.y) | 0}`)
+}
+
+/** The input_swipe agent tool: simulate a swipe. */
+function inputSwipeTool(engine) {
+  return inputShellTool(engine, 'input_swipe',
+    'Simulate a swipe/drag on the device screen from (x1,y1) to (x2,y2), optionally with a duration in ms.',
+    {
+      x1: { type: 'integer', description: 'Start X.' }, y1: { type: 'integer', description: 'Start Y.' },
+      x2: { type: 'integer', description: 'End X.' }, y2: { type: 'integer', description: 'End Y.' },
+      duration: { type: 'integer', description: 'Duration in ms (optional, default 200).' },
+    },
+    (a) => `input swipe ${Number(a.x1) | 0} ${Number(a.y1) | 0} ${Number(a.x2) | 0} ${Number(a.y2) | 0} ${Math.max(Number(a.duration ?? 200) || 200, 0)}`)
+}
+
+/** The input_text agent tool: type text (spaces become %s, shell chars escaped). */
+function inputTextTool(engine) {
+  return inputShellTool(engine, 'input_text',
+    'Type text into the focused field on the device (adb shell input text). Spaces are sent as %s; escape special characters as needed.',
+    { text: { type: 'string', description: 'The text to type, e.g. "hello world".' } },
+    (a) => {
+      const raw = typeof a.text === 'string' ? a.text : ''
+      const safe = raw.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/ /g, '%s')
+      return `input text "${safe}"`
+    })
+}
+
+/** The ui_dump agent tool: dump the current UI hierarchy (uiautomator). */
+function uiDumpTool(engine) {
+  return defineTool({
+    name: 'ui_dump',
+    description: 'Dump the current UI hierarchy of the device screen as XML (uiautomator dump) — lets you see buttons/text/coordinates on screen for UI automation.',
+    parameters: {
+      serial: { type: 'string', description: 'Device serial from logcat_devices (optional; defaults to the first attached device).' },
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          ok: { type: 'boolean', required: true },
+          xml: { type: 'string' },
+          error: { type: 'string' },
+        },
+      },
+      render: (_args, value) => {
+        if (value?.ok !== true || !value.xml) return [{ type: 'text', text: value?.error ?? '(dump failed)' }]
+        const xml = value.xml
+        const clipped = xml.length > 6000 ? xml.slice(0, 6000) + `\n… (truncated, full ${xml.length} chars)` : xml
+        return [{ type: 'text', text: clipped }]
+      },
+    },
+    async execute(args) {
+      const devices = engine.deviceList()
+      const serial = typeof args.serial === 'string' && args.serial !== ''
+        ? args.serial
+        : devices.find((d) => d.state === 'device')?.serial ?? ''
+      if (engine.adb === null) return { ok: false, error: 'adb not found on this host' }
+      if (serial === '') return { ok: false, error: 'no attached device; connect and authorize one first' }
+      const result = await runAdbFull(engine.adb, ['-s', serial, 'shell', 'uiautomator dump /sdcard/dsh-ui.xml >/dev/null 2>&1; cat /sdcard/dsh-ui.xml'], 30000)
+      const xml = result.stdout.trim()
+      if (result.ok && xml.startsWith('<?xml')) return { ok: true, xml }
+      return { ok: false, error: (result.stderr || result.stdout || `dump failed (exit ${result.code ?? '?'})`).slice(0, 500) }
+    },
+  })
+}
+
+/** --------------------------------------------------- reverse-engineering */
+
+/** The proc_list agent tool: structured process list. */
+function procListTool(engine) {
+  return defineTool({
+    name: 'proc_list',
+    description: 'List running processes on the device (pid, ppid, user, name) — find a process by name before reading its maps / memory.',
+    parameters: {
+      serial: { type: 'string', description: 'Device serial from logcat_devices (optional; defaults to the first attached device).' },
+      filter: { type: 'string', description: 'Optional case-insensitive substring to filter process names, e.g. "game" or "com.example".' },
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          processes: {
+            type: 'array',
+            required: true,
+            items: {
+              type: 'object',
+              additionalProperties: false,
+              properties: {
+                pid: { type: 'integer', required: true },
+                ppid: { type: 'integer' },
+                user: { type: 'string' },
+                name: { type: 'string', required: true },
+              },
+            },
+          },
+        },
+      },
+      render: (_args, value) => {
+        const list = value?.processes ?? []
+        if (list.length === 0) return [{ type: 'text', text: '(no processes)' }]
+        const lines = list.map((p) => `${String(p.pid).padStart(6)} ${(p.user ?? '?').padEnd(10)} ${p.name}`)
+        return [{ type: 'text', text: lines.join('\n') }]
+      },
+    },
+    async execute(args) {
+      const devices = engine.deviceList()
+      const serial = typeof args.serial === 'string' && args.serial !== '' ? args.serial : devices[0]?.serial ?? ''
+      if (serial === '' || engine.adb === null) return { processes: [] }
+      const needle = (typeof args.filter === 'string' ? args.filter.trim() : '').toLowerCase()
+      const result = await runAdbFull(engine.adb, ['-s', serial, 'shell', 'ps -A -o PID,PPID,USER,NAME'], 20000)
+      const processes = []
+      for (const line of (result.stdout ?? '').split(/\r?\n/)) {
+        const m = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(\S+)\s*$/.exec(line)
+        if (m === null) continue
+        const name = m[4]
+        if (needle !== '' && !name.toLowerCase().includes(needle)) continue
+        processes.push({ pid: Number.parseInt(m[1], 10), ppid: Number.parseInt(m[2], 10), user: m[3], name })
+      }
+      return { processes }
+    },
+  })
+}
+
+/** The proc_maps agent tool: memory maps + module bases (reverse engineering core). */
+function procMapsTool(engine) {
+  return defineTool({
+    name: 'proc_maps',
+    description: 'Read /proc/<pid>/maps of a process and list memory-mapped modules (shared libraries, so bases) — ' +
+      'the foundation for reverse engineering (find module base addresses, offsets, permissions). ' +
+      'Note: reading other apps\' maps needs root or a debuggable/rooted device; own-process reads work via run-as on debuggable apps.',
+    parameters: {
+      serial: { type: 'string', description: 'Device serial from logcat_devices (optional; defaults to the first attached device).' },
+      pid: { type: 'integer', description: 'Process id (from proc_list).' },
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          pid: { type: 'integer', required: true },
+          modules: {
+            type: 'array',
+            required: true,
+            items: {
+              type: 'object',
+              additionalProperties: false,
+              properties: {
+                base: { type: 'string', required: true },
+                end: { type: 'string' },
+                perms: { type: 'string' },
+                path: { type: 'string' },
+              },
+            },
+          },
+          error: { type: 'string' },
+        },
+      },
+      render: (_args, value) => {
+        if (value?.error) return [{ type: 'text', text: value.error }]
+        const mods = value?.modules ?? []
+        if (mods.length === 0) return [{ type: 'text', text: `(pid ${value?.pid ?? '?'}: no file-backed mappings)` }]
+        const lines = mods.map((m) => `${m.base}${m.end ? '-' + m.end : ''} ${(m.perms ?? '').padEnd(4)} ${m.path}`)
+        return [{ type: 'text', text: lines.join('\n') }]
+      },
+    },
+    async execute(args) {
+      const devices = engine.deviceList()
+      const serial = typeof args.serial === 'string' && args.serial !== '' ? args.serial : devices[0]?.serial ?? ''
+      const pid = Number(args.pid)
+      if (serial === '' || engine.adb === null || !Number.isInteger(pid) || pid <= 0) return { pid: 0, modules: [], error: 'a valid pid is required' }
+      const result = await runAdbFull(engine.adb, ['-s', serial, 'shell', `cat /proc/${pid}/maps 2>&1`], 20000)
+      if (!result.ok || result.stderr.includes('Permission denied') || /Permission denied|No such file/.test(result.stdout)) {
+        return { pid, modules: [], error: `cannot read /proc/${pid}/maps (need root, or a debuggable app via run-as); output: ${(result.stdout || result.stderr).slice(0, 200)}` }
+      }
+      const seen = new Set()
+      const modules = []
+      for (const line of (result.stdout ?? '').split(/\r?\n/)) {
+        const m = /^([0-9a-f]+)-([0-9a-f]+)\s+([rwxps-]{4})\s+[0-9a-f]+\s+\S+\s+\d+\s+(.+)$/.exec(line)
+        if (m === null) continue
+        const path = m[4]
+        if (!path.startsWith('/')) continue
+        if (seen.has(path)) continue
+        seen.add(path)
+        modules.push({ base: m[1], end: m[2], perms: m[3], path })
+      }
+      return { pid, modules }
+    },
+  })
+}
+
+/** The proc_status agent tool: /proc/<pid>/status summary + smaps totals. */
+function procStatusTool(engine) {
+  return defineTool({
+    name: 'proc_status',
+    description: 'Read /proc/<pid>/status (state, uid, vm usage, threads) plus smaps Pss totals of a process — memory footprint analysis.',
+    parameters: {
+      serial: { type: 'string', description: 'Device serial from logcat_devices (optional; defaults to the first attached device).' },
+      pid: { type: 'integer', description: 'Process id (from proc_list).' },
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          pid: { type: 'integer', required: true },
+          name: { type: 'string' },
+          state: { type: 'string' },
+          uid: { type: 'string' },
+          vmSizeKb: { type: 'integer' },
+          vmRssKb: { type: 'integer' },
+          threads: { type: 'integer' },
+          pssKb: { type: 'integer' },
+          error: { type: 'string' },
+        },
+      },
+      render: (_args, value) => {
+        if (value?.error) return [{ type: 'text', text: value.error }]
+        const rows = ['name', 'state', 'uid', 'vmSizeKb', 'vmRssKb', 'threads', 'pssKb']
+          .filter((k) => value?.[k] !== undefined)
+          .map((k) => `${k}: ${value[k]}`)
+        return [{ type: 'text', text: rows.length > 0 ? rows.join('\n') : `(pid ${value?.pid ?? '?'}: no data)` }]
+      },
+    },
+    async execute(args) {
+      const devices = engine.deviceList()
+      const serial = typeof args.serial === 'string' && args.serial !== '' ? args.serial : devices[0]?.serial ?? ''
+      const pid = Number(args.pid)
+      if (serial === '' || engine.adb === null || !Number.isInteger(pid) || pid <= 0) return { pid: 0, error: 'a valid pid is required' }
+      const sh = `cat /proc/${pid}/status 2>&1; echo ===SMAPS===; awk '/^Pss:/ {s+=$2} END {print s}' /proc/${pid}/smaps 2>/dev/null; true`
+      const result = await runAdbFull(engine.adb, ['-s', serial, 'shell', sh], 20000)
+      if (!result.ok || result.stdout.trim() === '' || /No such file|No such process/.test(result.stdout)) {
+        return { pid, error: `cannot read /proc/${pid} (need root or debuggable app); output: ${(result.stdout || result.stderr).slice(0, 200)}` }
+      }
+      const [statusText, , smapsOut] = result.stdout.split(/\r?\n===SMAPS===\r?\n|\n===SMAPS===\n/)
+      const field = (k) => { const m = new RegExp(`^${k}:\\s*(.+)$`, 'm').exec(statusText ?? ''); return m ? m[1].trim() : undefined }
+      const kb = (k) => { const v = field(k); return v ? Number.parseInt(v, 10) || undefined : undefined }
+      return {
+        pid,
+        name: field('Name'),
+        state: field('State'),
+        uid: field('Uid'),
+        vmSizeKb: kb('VmSize'),
+        vmRssKb: kb('VmRSS'),
+        threads: kb('Threads'),
+        pssKb: Number.parseInt((smapsOut ?? '').trim(), 10) || undefined,
+      }
+    },
+  })
+}
+
+/** The mem_dump agent tool: read raw memory at an address (hex). */
+function memDumpTool(engine) {
+  return defineTool({
+    name: 'mem_dump',
+    description: 'Dump raw memory of a process at a given address as hex (via /proc/<pid>/mem) — for reverse engineering. ' +
+      'Requires root on most devices (or a debuggable app via run-as). Address in hex, length in bytes (max 65536, default 256).',
+    parameters: {
+      serial: { type: 'string', description: 'Device serial from logcat_devices (optional; defaults to the first attached device).' },
+      pid: { type: 'integer', description: 'Process id (from proc_list).' },
+      address: { type: 'string', description: 'Start address in hex, e.g. "0x7a0000" or "7a0000".' },
+      length: { type: 'integer', description: 'Bytes to read (default 256, max 65536).' },
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          pid: { type: 'integer', required: true },
+          address: { type: 'string' },
+          hex: { type: 'string' },
+          error: { type: 'string' },
+        },
+      },
+      render: (_args, value) => {
+        if (value?.error) return [{ type: 'text', text: value.error }]
+        return [{ type: 'text', text: value?.hex ? `pid ${value.pid} @ ${value.address}:\n${value.hex}` : '(no data)' }]
+      },
+    },
+    async execute(args) {
+      const devices = engine.deviceList()
+      const serial = typeof args.serial === 'string' && args.serial !== '' ? args.serial : devices[0]?.serial ?? ''
+      const pid = Number(args.pid)
+      const rawAddr = typeof args.address === 'string' ? args.address.trim() : ''
+      const addr = Number.parseInt(rawAddr.replace(/^0x/i, ''), 16)
+      const len = Math.min(Math.max(Number(args.length ?? 256) || 256, 1), 65536)
+      if (serial === '' || engine.adb === null || !Number.isInteger(pid) || pid <= 0) return { pid: 0, error: 'a valid pid is required' }
+      if (!Number.isFinite(addr) || addr < 0) return { pid, error: `invalid address: ${rawAddr}` }
+      const sh = `dd if=/proc/${pid}/mem bs=1 skip=${addr} count=${len} of=/sdcard/dsh-mem.bin 2>/dev/null && od -A x -t x1 -v /sdcard/dsh-mem.bin && rm /sdcard/dsh-mem.bin || echo DSH_MEM_FAIL`
+      const result = await runAdbFull(engine.adb, ['-s', serial, 'shell', sh], 20000)
+      if (!result.ok || result.stdout.includes('DSH_MEM_FAIL') || result.stdout.trim() === '') {
+        return { pid, error: `cannot read memory at ${rawAddr} (need root / debuggable app); output: ${(result.stdout + result.stderr).slice(0, 200)}` }
+      }
+      return { pid, address: '0x' + addr.toString(16), hex: result.stdout.trim() }
+    },
+  })
+}
+
+/** The frida_server agent tool: deploy / start / stop frida-server. */
+function fridaServerTool(engine) {
+  return defineTool({
+    name: 'frida_server',
+    description: 'Manage frida-server on the device for dynamic instrumentation (reverse engineering): ' +
+      'status (is it deployed/running), start (push a local frida-server binary and run it), stop (kill it). ' +
+      'The frida-server binary must match the device ABI (arm64/arm/x86) — get it from the frida releases page.',
+    parameters: {
+      serial: { type: 'string', description: 'Device serial from logcat_devices (optional; defaults to the first attached device).' },
+      action: { type: 'string', enum: ['status', 'start', 'stop'], description: 'What to do: status / start / stop.' },
+      localPath: { type: 'string', description: 'Absolute local path of the frida-server binary (required for start), e.g. "F:/tools/frida-server-16.5.5-android-arm64".' },
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          ok: { type: 'boolean', required: true },
+          running: { type: 'boolean' },
+          pid: { type: 'integer' },
+          output: { type: 'string' },
+          error: { type: 'string' },
+        },
+      },
+      render: (_args, value) => {
+        if (value?.error) return [{ type: 'text', text: value.error }]
+        const parts = []
+        if (value?.running !== undefined) parts.push(`running: ${value.running}${value.pid ? ` (pid ${value.pid})` : ''}`)
+        if (value?.output) parts.push(value.output.trimEnd())
+        return [{ type: 'text', text: parts.length > 0 ? parts.join('\n') : `ok: ${value?.ok}` }]
+      },
+    },
+    async execute(args) {
+      const devices = engine.deviceList()
+      const serial = typeof args.serial === 'string' && args.serial !== ''
+        ? args.serial
+        : devices.find((d) => d.state === 'device')?.serial ?? ''
+      const action = typeof args.action === 'string' ? args.action : 'status'
+      if (engine.adb === null) return { ok: false, error: 'adb not found on this host' }
+      if (serial === '') return { ok: false, error: 'no attached device; connect and authorize one first' }
+      if (action === 'start') {
+        const localPath = typeof args.localPath === 'string' ? args.localPath.trim() : ''
+        if (localPath === '' || !existsSync(localPath)) return { ok: false, error: `frida-server binary not found: ${localPath || '(none given)'}` }
+        const push = await runAdbFull(engine.adb, ['-s', serial, 'push', localPath, '/data/local/tmp/frida-server'], 120000)
+        if (!push.ok) return { ok: false, error: `push failed: ${(push.stderr || push.stdout).slice(0, 200)}` }
+        await runAdbFull(engine.adb, ['-s', serial, 'shell', 'chmod 755 /data/local/tmp/frida-server'], 10000)
+        const start = await runAdbFull(engine.adb, ['-s', serial, 'shell', 'nohup /data/local/tmp/frida-server >/dev/null 2>&1 &'], 10000)
+        if (!start.ok) return { ok: false, error: `start failed: ${(start.stderr || start.stdout).slice(0, 200)}` }
+        const check = await runAdbFull(engine.adb, ['-s', serial, 'shell', 'ps -A | grep frida-server | head -1'], 10000)
+        const m = /^\s*(\d+)/.exec(check.stdout ?? '')
+        return { ok: true, running: m !== null, pid: m ? Number.parseInt(m[1], 10) : undefined, output: 'frida-server started' }
+      }
+      if (action === 'stop') {
+        const stop = await runAdbFull(engine.adb, ['-s', serial, 'shell', 'pkill -f frida-server; echo stopped'], 10000)
+        return { ok: stop.ok, running: false, output: 'frida-server stopped' }
+      }
+      // status
+      const exists = await runAdbFull(engine.adb, ['-s', serial, 'shell', 'ls -l /data/local/tmp/frida-server 2>&1'], 10000)
+      const running = await runAdbFull(engine.adb, ['-s', serial, 'shell', 'ps -A | grep frida-server | head -1'], 10000)
+      const m = /^\s*(\d+)/.exec(running.stdout ?? '')
+      return {
+        ok: true,
+        running: m !== null,
+        pid: m ? Number.parseInt(m[1], 10) : undefined,
+        output: `deployed: ${exists.ok ? 'yes' : 'no'}\n` + ((running.stdout ?? '').trim() || 'not running'),
+      }
+    },
+  })
+}
+
 /** ------------------------------------------------------------------ */
 
 /** Mount the adb engine, routes, tool, and announcement. */
@@ -982,6 +1591,18 @@ export function apply(ctx, config) {
         logcatSetPackageTool(engine),
         adbInstallTool(engine),
         adbPullTool(engine),
+        logcatCrashTool(engine),
+        deviceInfoTool(engine),
+        deviceStatsTool(engine),
+        inputTapTool(engine),
+        inputSwipeTool(engine),
+        inputTextTool(engine),
+        uiDumpTool(engine),
+        procListTool(engine),
+        procMapsTool(engine),
+        procStatusTool(engine),
+        memDumpTool(engine),
+        fridaServerTool(engine),
       ].map((tool) => ctx.tools.register(tool))
       return () => { for (const dispose of disposers) dispose() }
     }, 'dsh-logcat: tools')

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@windypro-rourou/dsh-logcat",
   "description": "Android Logcat viewer for the dsh web GUI: auto-connects to any adb device in debug mode, live logcat stream with level/keyword filters, pause/clear/export, plus agent tools (logcat_recent). Hot-pluggable — mounted via ~/.dsh/cordis.patch.yml + a profile node_modules copy, no dsh source changes.",
-  "version": "0.2.9",
+  "version": "0.3.0",
   "type": "module",
   "packageManager": "pnpm@11.22.0",
   "engines": {