frida-trace

71 |

72 | 73 | 74 | { 77 | if (e.key === "Enter") { 78 | e.preventDefault(); 79 | adjustAddress(0); 80 | } 81 | }} 82 | placeholder="Memory address…" 83 | /> 84 | 85 | 86 | 109 |

110 |

111 |

112 | ); 113 | } 114 | -------------------------------------------------------------------------------- /apps/tracer/src/HandlerList.tsx: -------------------------------------------------------------------------------- 1 | import "./HandlerList.css"; 2 | import { Handler, ScopeId, HandlerId } from "./model.js"; 3 | import { Tree, TreeNodeInfo } from "@blueprintjs/core"; 4 | import { useEffect, useRef, useState } from "react"; 5 | 6 | export interface HandlerListProps { 7 | handlers: Handler[]; 8 | selectedScope: ScopeId; 9 | onScopeSelect: ScopeEventHandler; 10 | selectedHandler: HandlerId | null; 11 | onHandlerSelect: HandlerEventHandler; 12 | } 13 | 14 | export type ScopeEventHandler = (id: ScopeId) => void; 15 | export type HandlerEventHandler = (id: HandlerId) => void; 16 | 17 | export default function HandlerList({ handlers, selectedScope, onScopeSelect, selectedHandler, onHandlerSelect }: HandlerListProps) { 18 | const treeRef = useRef(null); 19 | const [mouseInsideNode, setMouseInsideNode] = useState(false); 20 | 21 | const scopes = handlers.reduce((result, { scope }) => result.add(scope), new Set()); 22 | const handlerNodes: TreeNodeInfo[] = Array.from(scopes).map(scope => { 23 | const isExpanded = scope === selectedScope; 24 | return { 25 | id: scope, 26 | label: labelFromScope(scope), 27 | isExpanded, 28 | icon: isExpanded ? "folder-open" : "folder-close", 29 | childNodes: handlers 30 | .filter(h => h.scope === scope) 31 | .map(({ id, display_name, config }) => { 32 | return { 33 | id, 34 | label: display_name, 35 | isSelected: id === selectedHandler, 36 | icon: "code-block", 37 | className: config.muted ? "handler-node-muted" : "", 38 | }; 39 | }), 40 | }; 41 | }); 42 | 43 | function handleNodeClick(node: TreeNodeInfo) { 44 | if (typeof node.id === "string") { 45 | onScopeSelect((selectedScope !== node.id) ? node.id : ""); 46 | } else { 47 | onHandlerSelect(node.id as HandlerId); 48 | } 49 | } 50 | 51 | function handleNodeExpand(node: TreeNodeInfo) { 52 | onScopeSelect(node.id as ScopeId); 53 | } 54 | 55 | function handleNodeCollapse() { 56 | onScopeSelect(""); 57 | } 58 | 59 | useEffect(() => { 60 | if (selectedHandler === null || mouseInsideNode) { 61 | return; 62 | } 63 | 64 | const tree = treeRef.current; 65 | if (tree === null) { 66 | return; 67 | } 68 | 69 | const scopeElement = tree.getNodeContentElement(selectedScope); 70 | if (scopeElement === undefined) { 71 | return; 72 | } 73 | 74 | scopeElement.addEventListener("transitionend", scrollIntoView); 75 | 76 | requestAnimationFrame(scrollIntoView); 77 | 78 | function scrollIntoView() { 79 | tree!.getNodeContentElement(selectedHandler!)?.scrollIntoView({ block: "center" }); 80 | } 81 | 82 | return () => { 83 | scopeElement.removeEventListener("transitionend", scrollIntoView); 84 | }; 85 | }, [treeRef, selectedScope, selectedHandler, mouseInsideNode]); 86 | 87 | return ( 88 | setMouseInsideNode(true)} 93 | onNodeMouseLeave={() => setMouseInsideNode(false)} 94 | onNodeClick={handleNodeClick} 95 | onNodeExpand={handleNodeExpand} 96 | onNodeCollapse={handleNodeCollapse} 97 | /> 98 | ); 99 | } 100 | 101 | function labelFromScope(scope: string) { 102 | let dirsepIndex = scope.lastIndexOf("/"); 103 | if (dirsepIndex === -1) { 104 | dirsepIndex = scope.lastIndexOf("\\"); 105 | } 106 | if (dirsepIndex === -1) { 107 | return scope; 108 | } 109 | return scope.substring(dirsepIndex + 1); 110 | } 111 | -------------------------------------------------------------------------------- /agents/repl/agent.ts: -------------------------------------------------------------------------------- 1 | class REPL { 2 | #quickCommands = new Map(); 3 | 4 | registerQuickCommand(name: string, handler: QuickCommandHandler) { 5 | this.#quickCommands.set(name, handler); 6 | } 7 | 8 | unregisterQuickCommand(name: string) { 9 | this.#quickCommands.delete(name); 10 | } 11 | 12 | _invokeQuickCommand(tokens: string[]): any { 13 | const name = tokens[0]; 14 | const handler = this.#quickCommands.get(name); 15 | if (handler !== undefined) { 16 | const { minArity, onInvoke } = handler; 17 | if (tokens.length - 1 < minArity) { 18 | throw Error(`${name} needs at least ${minArity} arg${(minArity === 1) ? "" : "s"}`); 19 | } 20 | return onInvoke(...tokens.slice(1)); 21 | } else { 22 | throw Error(`Unknown command ${name}`); 23 | } 24 | } 25 | } 26 | 27 | const repl = new REPL(); 28 | 29 | globalThis.REPL = repl; 30 | globalThis.cm = null; 31 | globalThis.cs = {}; 32 | 33 | registerLazyBridgeGetter("ObjC"); 34 | registerLazyBridgeGetter("Swift"); 35 | registerLazyBridgeGetter("Java"); 36 | 37 | function registerLazyBridgeGetter(name: string) { 38 | Object.defineProperty(globalThis, name, { 39 | enumerable: true, 40 | configurable: true, 41 | get() { 42 | return lazyLoadBridge(name); 43 | } 44 | }); 45 | } 46 | 47 | function lazyLoadBridge(name: string): unknown { 48 | send({ type: "frida:load-bridge", name }); 49 | let bridge: unknown; 50 | recv("frida:bridge-loaded", message => { 51 | bridge = Script.evaluate(`/frida/bridges/${message.filename}`, 52 | "(function () { " + [ 53 | message.source, 54 | `Object.defineProperty(globalThis, '${name}', { value: bridge });`, 55 | `return bridge;` 56 | ].join("\n") + " })();"); 57 | }).wait(); 58 | return bridge; 59 | } 60 | 61 | declare global { 62 | var REPL: REPL; 63 | var cm: CModule | null; 64 | var cs: { 65 | [name: string]: NativePointerValue; 66 | }; 67 | } 68 | 69 | interface QuickCommandHandler { 70 | minArity: number; 71 | onInvoke: (...args: string[]) => any; 72 | } 73 | 74 | const rpcExports: RpcExports = { 75 | fridaEvaluateExpression(expression: string) { 76 | return evaluate(() => globalThis.eval(expression)); 77 | }, 78 | fridaEvaluateQuickCommand(tokens: string[]) { 79 | return evaluate(() => repl._invokeQuickCommand(tokens)); 80 | }, 81 | fridaLoadCmodule(code: string | null, toolchain: CModuleToolchain) { 82 | const cs = globalThis.cs; 83 | 84 | if (cs._frida_log === undefined) 85 | cs._frida_log = new NativeCallback(onLog, "void", ["pointer"]); 86 | 87 | let codeToLoad: string | ArrayBuffer | null = code; 88 | if (code === null) { 89 | recv("frida:cmodule-payload", (message, data) => { 90 | codeToLoad = data; 91 | }); 92 | } 93 | 94 | globalThis.cm = new CModule(codeToLoad!, cs, { toolchain }); 95 | }, 96 | }; 97 | 98 | function evaluate(func: () => any) { 99 | try { 100 | const result = func(); 101 | if (result instanceof ArrayBuffer) { 102 | return result; 103 | } else { 104 | const type = (result === null) ? "null" : typeof result; 105 | return [type, result]; 106 | } 107 | } catch (exception) { 108 | const e = exception as Error; 109 | return ["error", { 110 | name: e.name, 111 | message: e.message, 112 | stack: e.stack 113 | }]; 114 | } 115 | } 116 | 117 | Object.defineProperty(rpc, "exports", { 118 | get() { 119 | return rpcExports; 120 | }, 121 | set(value) { 122 | for (const [k, v] of Object.entries(value)) { 123 | rpcExports[k] = v as AnyFunction; 124 | } 125 | } 126 | }); 127 | 128 | function onLog(messagePtr: NativePointer) { 129 | const message = messagePtr.readUtf8String(); 130 | console.log(message); 131 | } 132 | -------------------------------------------------------------------------------- /frida_tools/ls.py: -------------------------------------------------------------------------------- 1 | import argparse 2 | import codecs 3 | import os 4 | from datetime import datetime, timezone 5 | from operator import itemgetter 6 | from typing import Any, List 7 | 8 | from colorama import Fore, Style 9 | 10 | from frida_tools.application import ConsoleApplication 11 | 12 | STYLE_DIR = Fore.BLUE + Style.BRIGHT 13 | STYLE_EXECUTABLE = Fore.GREEN + Style.BRIGHT 14 | STYLE_LINK = Fore.CYAN + Style.BRIGHT 15 | STYLE_ERROR = Fore.RED + Style.BRIGHT 16 | 17 | 18 | def main() -> None: 19 | app = LsApplication() 20 | app.run() 21 | 22 | 23 | class LsApplication(ConsoleApplication): 24 | def _add_options(self, parser: argparse.ArgumentParser) -> None: 25 | parser.add_argument("files", help="files to list information about", nargs="*") 26 | 27 | def _usage(self) -> str: 28 | return "%(prog)s [options] [FILE]..." 29 | 30 | def _initialize(self, parser: argparse.ArgumentParser, options: argparse.Namespace, args: List[str]) -> None: 31 | self._files = options.files 32 | 33 | def _needs_target(self) -> bool: 34 | return False 35 | 36 | def _start(self) -> None: 37 | try: 38 | self._attach(self._pick_worker_pid()) 39 | 40 | data_dir = os.path.dirname(__file__) 41 | with codecs.open(os.path.join(data_dir, "fs_agent.js"), "r", "utf-8") as f: 42 | source = f.read() 43 | 44 | def on_message(message: Any, data: Any) -> None: 45 | print(message) 46 | 47 | assert self._session is not None 48 | script = self._session.create_script(name="ls", source=source) 49 | script.on("message", on_message) 50 | self._on_script_created(script) 51 | script.load() 52 | 53 | groups = script.exports_sync.ls(self._files) 54 | except Exception as e: 55 | self._update_status(f"Failed to retrieve listing: {e}") 56 | self._exit(1) 57 | return 58 | 59 | exit_status = 0 60 | for i, group in enumerate(sorted(groups, key=lambda g: g["path"])): 61 | path = group["path"] 62 | if path != "" and len(groups) > 1: 63 | if i > 0: 64 | self._print("") 65 | self._print(path + ":") 66 | 67 | for path, message in group["errors"]: 68 | self._print(STYLE_ERROR + message + Style.RESET_ALL) 69 | exit_status = 2 70 | 71 | rows = [] 72 | for name, target, type, access, nlink, owner, group, size, raw_mtime in group["entries"]: 73 | mtime = datetime.fromtimestamp(raw_mtime / 1000.0, tz=timezone.utc) 74 | rows.append((type + access, str(nlink), owner, group, str(size), mtime.strftime("%c"), name, target)) 75 | 76 | if len(rows) == 0: 77 | break 78 | 79 | widths = [] 80 | for column_index in range(len(rows[0]) - 2): 81 | width = max(map(lambda row: len(row[column_index]), rows)) 82 | widths.append(width) 83 | 84 | adjustments = [ 85 | "", 86 | ">", 87 | "<", 88 | "<", 89 | ">", 90 | "<", 91 | ] 92 | col_formats = [] 93 | for i, width in enumerate(widths): 94 | adj = adjustments[i] 95 | if adj != "": 96 | fmt = "{:" + adj + str(width) + "}" 97 | else: 98 | fmt = "{}" 99 | col_formats.append(fmt) 100 | row_description = " ".join(col_formats) 101 | 102 | for row in sorted(rows, key=itemgetter(6)): 103 | meta_fields = row_description.format(*row[:-2]) 104 | 105 | name, target = row[6:8] 106 | ftype_and_perms = row[0] 107 | ftype = ftype_and_perms[0] 108 | fperms = ftype_and_perms[1:] 109 | name = format_name(name, ftype, fperms, target) 110 | 111 | self._print(meta_fields + " " + name) 112 | 113 | self._exit(exit_status) 114 | 115 | 116 | def format_name(name: str, ftype: str, fperms: str, target) -> str: 117 | if ftype == "l": 118 | target_path, target_details = target 119 | if target_details is not None: 120 | target_type, target_perms = target_details 121 | target_summary = format_name(target_path, target_type, target_perms, None) 122 | else: 123 | target_summary = STYLE_ERROR + target_path + Style.RESET_ALL 124 | return STYLE_LINK + name + Style.RESET_ALL + " -> " + target_summary 125 | 126 | if ftype == "d": 127 | return STYLE_DIR + name + Style.RESET_ALL 128 | 129 | if "x" in fperms: 130 | return STYLE_EXECUTABLE + name + Style.RESET_ALL 131 | 132 | return name 133 | 134 | 135 | if __name__ == "__main__": 136 | try: 137 | main() 138 | except KeyboardInterrupt: 139 | pass 140 | -------------------------------------------------------------------------------- /agents/itracer/agent.ts: -------------------------------------------------------------------------------- 1 | import { 2 | TraceBuffer, 3 | TraceBufferReader, 4 | TraceSession, 5 | TraceStrategy, 6 | } from "frida-itrace"; 7 | 8 | type RawTraceStrategy = RawTraceThreadStrategy | RawTraceRangeStrategy; 9 | type RawTraceThreadStrategy = ["thread", ["id", number] | ["index", number]]; 10 | type RawTraceRangeStrategy = ["range", [CodeLocation, CodeLocation | null]] 11 | 12 | type CodeLocation = 13 | | ["address", string] 14 | | ["module-export", [string, string]] 15 | | ["module-offset", [string, number]] 16 | | ["symbol", string] 17 | ; 18 | 19 | const BUFFER_READER_POLL_INTERVAL_MSEC = 10; 20 | 21 | class Agent { 22 | session: TraceSession | null = null; 23 | buffer: TraceBuffer | null = null; 24 | reader: TraceBufferReader | null = null; 25 | drainTimer: NodeJS.Timeout | null = null; 26 | 27 | createBuffer(): string { 28 | this.buffer = TraceBuffer.create(); 29 | return this.buffer.location; 30 | } 31 | 32 | openBuffer(location: string) { 33 | this.buffer = TraceBuffer.open(location); 34 | } 35 | 36 | launchBufferReader() { 37 | this.reader = new TraceBufferReader(this.buffer!); 38 | this.drainTimer = setInterval(this.#drainBuffer, BUFFER_READER_POLL_INTERVAL_MSEC); 39 | } 40 | 41 | stopBufferReader() { 42 | clearInterval(this.drainTimer!); 43 | this.drainTimer = null; 44 | 45 | this.#drainBuffer(); 46 | 47 | this.reader = null; 48 | } 49 | 50 | #drainBuffer = () => { 51 | const chunk = this.reader!.read(); 52 | if (chunk.byteLength === 0) { 53 | return; 54 | } 55 | send({ type: "itrace:chunk" }, chunk); 56 | 57 | const lost = this.reader!.lost; 58 | if (lost !== 0) { 59 | send({ type: "itrace:lost", payload: { lost } }); 60 | } 61 | }; 62 | 63 | launchTraceSession(rawStrategy: RawTraceStrategy) { 64 | const strategy = parseTraceStrategy(rawStrategy); 65 | const session = new TraceSession(strategy, this.buffer!); 66 | this.session = session; 67 | 68 | session.events.on("start", (regSpecs, regValues) => { 69 | send({ type: "itrace:start", payload: regSpecs }, regValues); 70 | }); 71 | session.events.on("end", () => { 72 | send({ type: "itrace:end" }); 73 | }); 74 | session.events.on("compile", block => { 75 | send({ type: "itrace:compile", payload: block }); 76 | }); 77 | session.events.on("panic", message => { 78 | console.error(message); 79 | }); 80 | 81 | session.open(); 82 | } 83 | 84 | queryProgramName() { 85 | return Process.enumerateModules()[0].name; 86 | } 87 | 88 | listThreads() { 89 | return Process.enumerateThreads(); 90 | } 91 | } 92 | 93 | function parseTraceStrategy(rawStrategy: RawTraceStrategy): TraceStrategy { 94 | const [kind, params] = rawStrategy; 95 | switch (kind) { 96 | case "thread": { 97 | let thread: ThreadDetails; 98 | const threads = Process.enumerateThreads(); 99 | switch (params[0]) { 100 | case "id": { 101 | const desiredId = params[1]; 102 | const th = threads.find(t => t.id === desiredId); 103 | if (th === undefined) { 104 | throw new Error("invalid thread ID"); 105 | } 106 | thread = th; 107 | break; 108 | } 109 | case "index": { 110 | thread = threads[params[1]]; 111 | if (thread === undefined) { 112 | throw new Error("invalid thread index"); 113 | } 114 | break; 115 | } 116 | } 117 | return { 118 | type: "thread", 119 | threadId: thread.id 120 | }; 121 | } 122 | case "range": { 123 | return { 124 | type: "range", 125 | start: parseCodeLocation(params[0]), 126 | end: parseCodeLocation(params[1]) 127 | }; 128 | } 129 | } 130 | } 131 | 132 | function parseCodeLocation(location: CodeLocation | null): NativePointer { 133 | if (location === null) { 134 | return NULL; 135 | } 136 | 137 | const [kind, params] = location; 138 | switch (kind) { 139 | case "address": { 140 | const address = ptr(params); 141 | try { 142 | address.readVolatile(1); 143 | } catch (e) { 144 | throw new Error(`invalid address: ${address}`); 145 | } 146 | return address; 147 | } 148 | case "module-export": 149 | return Process.getModuleByName(params[0]).getExportByName(params[1]); 150 | case "module-offset": 151 | return Process.getModuleByName(params[0]).base.add(params[1]); 152 | case "symbol": { 153 | const name = params; 154 | const { address } = DebugSymbol.fromName(name); 155 | if (!address.isNull()) { 156 | return address; 157 | } 158 | return Module.getGlobalExportByName(name); 159 | } 160 | } 161 | } 162 | 163 | const agent = new Agent(); 164 | 165 | const agentMethodNames = Object.getOwnPropertyNames(Object.getPrototypeOf(agent)) 166 | .filter(name => name !== "constructor"); 167 | for (const name of agentMethodNames) { 168 | rpc.exports[name] = (agent as any)[name].bind(agent); 169 | } 170 | -------------------------------------------------------------------------------- /apps/tracer/src/AddTargetsDialog.tsx: -------------------------------------------------------------------------------- 1 | import "./AddTargetsDialog.css"; 2 | import { TraceSpecScope, StagedItem, StagedItemId } from "./model.js"; 3 | import { 4 | Button, 5 | ButtonGroup, 6 | Card, 7 | CardList, 8 | Dialog, 9 | DialogBody, 10 | DialogFooter, 11 | FormGroup, 12 | InputGroup, 13 | Menu, 14 | MenuItem, 15 | Popover 16 | } from "@blueprintjs/core"; 17 | import { useRef, useState } from "react"; 18 | import { useDebouncedCallback } from "use-debounce"; 19 | 20 | export interface AddTargetsProps { 21 | isOpen: boolean; 22 | stagedItems: StagedItem[]; 23 | onClose: CloseEventHandler; 24 | onQuery: QueryEventHandler; 25 | onCommit: CommitEventHandler; 26 | } 27 | 28 | export type CloseEventHandler = () => void; 29 | export type QueryEventHandler = (scope: TraceSpecScope, query: string) => void; 30 | export type CommitEventHandler = (id: StagedItemId | null) => void; 31 | 32 | export default function AddTargetsDialog({ isOpen, stagedItems, onClose, onQuery, onCommit }: AddTargetsProps) { 33 | const inputRef = useRef(null); 34 | const onQueryDebounced = useDebouncedCallback(onQuery, 250); 35 | const [scope, setScope] = useState(TraceSpecScope.Function); 36 | 37 | const kindMenu = ( 38 | 41 | { 42 | Object.keys(TraceSpecScope) 43 | .map(s => ( 44 | setScope((TraceSpecScope as any)[s])} 48 | /> 49 | )) 50 | } 51 | 52 | } 53 | placement="bottom-end" 54 | > 55 | 58 | 59 | ); 60 | 61 | const actions = ( 62 | 63 | 64 | 65 | 66 | ); 67 | 68 | const candidates = (stagedItems.length !== 0) ? ( 69 | 70 | 71 | {stagedItems.map(([id, scope, member]) => { 72 | return ( 73 | 74 | {scope}!{member} 75 | 123 | {(spawnedProgram !== null) ? : null} 124 | 125 | 126 |

127 | {connectionError} 128 |

129 | 130 | 137 | 144 | 157 | 158 |

159 | setHandlerMuted(e.target.checked)} 164 | > 165 | Muted 166 | 167 | setCaptureBacktraces(e.target.checked)} 171 | > 172 | Capture Backtraces 173 | 174 |

175 |

176 | 182 |

183 | 184 | 185 | 186 | setSelectedTabId(tabId as any)} animate={false}> 187 | 188 | 189 | 190 | 191 | 192 | 193 | 200 | 201 |

202 | 203 | 204 | ); 205 | } 206 | -------------------------------------------------------------------------------- /frida_tools/pm.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | from __future__ import annotations 3 | 4 | import argparse 5 | import html 6 | import itertools 7 | import json 8 | import os 9 | import re 10 | import sys 11 | import textwrap 12 | import threading 13 | import time 14 | from typing import List, Optional 15 | 16 | import frida 17 | from colorama import Style 18 | from prompt_toolkit.formatted_text import HTML 19 | from prompt_toolkit.shortcuts import print_formatted_text 20 | 21 | from frida_tools.application import ConsoleApplication 22 | from frida_tools.cli_formatting import THEME_COLOR 23 | 24 | VERSION_COLOR = "#9e9e9e" 25 | 26 | THEME_ATTR = f'fg="{THEME_COLOR}"' 27 | VERSION_ATTR = f'fg="{VERSION_COLOR}"' 28 | 29 | ANSI_PATTERN = re.compile(r"\x1b\[[0-9;]*m") 30 | 31 | SPINNER_DELAY = 0.25 32 | 33 | 34 | def main() -> None: 35 | PackageManagerApplication().run() 36 | 37 | 38 | class PackageManagerApplication(ConsoleApplication): 39 | def _usage(self) -> str: 40 | return "%(prog)s [options] [...]" 41 | 42 | def _add_options(self, parser: argparse.ArgumentParser) -> None: 43 | default_registry = frida.PackageManager().registry 44 | parser.add_argument( 45 | "--registry", 46 | metavar="HOST", 47 | default=None, 48 | help=f"package registry to use (default: {default_registry})", 49 | ) 50 | 51 | sub = parser.add_subparsers(dest="command", metavar="", required=True) 52 | 53 | search_p = sub.add_parser("search", help="search for packages") 54 | search_p.add_argument("query", nargs="?", default="", help="search string, e.g. 'trace'") 55 | search_p.add_argument("--offset", type=int, metavar="N", help="result offset") 56 | search_p.add_argument("--limit", type=int, metavar="N", help="max results") 57 | search_p.add_argument( 58 | "--json", 59 | action="store_true", 60 | help="emit raw JSON instead of a table", 61 | ) 62 | 63 | install_p = sub.add_parser("install", help="install one or more packages") 64 | install_p.add_argument( 65 | "specs", 66 | nargs="*", 67 | metavar="SPEC", 68 | help="package spec, e.g. 'frida-objc-bridge@^8.0.5' or 'frida-il2cpp-bridge'", 69 | ) 70 | install_p.add_argument( 71 | "--project-root", 72 | default=os.getcwd(), 73 | metavar="DIR", 74 | help="directory that will receive node_modules (default: CWD)", 75 | ) 76 | role_group = install_p.add_mutually_exclusive_group() 77 | role_group.add_argument( 78 | "-P", 79 | "--save-prod", 80 | action="store_const", 81 | const="runtime", 82 | dest="role", 83 | help="save as production dependencies (default)", 84 | ) 85 | role_group.add_argument( 86 | "-D", 87 | "--save-dev", 88 | action="store_const", 89 | const="development", 90 | dest="role", 91 | help="save as development dependencies", 92 | ) 93 | role_group.add_argument( 94 | "--save-optional", action="store_const", const="optional", dest="role", help="save as optional dependencies" 95 | ) 96 | install_p.add_argument( 97 | "--omit", 98 | help="dependency types to skip", 99 | choices=["dev", "optional", "peer"], 100 | dest="omits", 101 | action="append", 102 | ) 103 | install_p.add_argument("--quiet", action="store_true", help="suppress the progress bar") 104 | 105 | def _initialize( 106 | self, 107 | parser: argparse.ArgumentParser, 108 | options: argparse.Namespace, 109 | args: List[str], 110 | ) -> None: 111 | self._opts = options 112 | 113 | pm = frida.PackageManager() 114 | if options.registry is not None: 115 | pm.registry = options.registry 116 | self._pm = pm 117 | 118 | def _needs_device(self) -> bool: 119 | return False 120 | 121 | def _start(self) -> None: 122 | try: 123 | if self._opts.command == "search": 124 | self._cmd_search() 125 | elif self._opts.command == "install": 126 | self._cmd_install() 127 | self._exit(0) 128 | except Exception as e: 129 | self._log("error", str(e)) 130 | self._exit(1) 131 | 132 | def _cmd_search(self) -> None: 133 | interactive = self._have_terminal and not self._plain_terminal 134 | show_spinner = (not self._opts.json) and interactive 135 | 136 | stop_event = None 137 | spinner_thread = None 138 | if show_spinner: 139 | stop_event, spinner_thread = start_spinner(THEME_COLOR) 140 | 141 | try: 142 | res = self._pm.search( 143 | self._opts.query, 144 | offset=self._opts.offset, 145 | limit=self._opts.limit, 146 | ) 147 | finally: 148 | if stop_event is not None: 149 | stop_event.set() 150 | if spinner_thread is not None: 151 | spinner_thread.join() 152 | 153 | if self._opts.json: 154 | print( 155 | json.dumps( 156 | { 157 | "packages": [ 158 | { 159 | "name": p.name, 160 | "version": p.version, 161 | "description": p.description, 162 | "url": p.url, 163 | } 164 | for p in res.packages 165 | ], 166 | "total": res.total, 167 | }, 168 | indent=2, 169 | sort_keys=True, 170 | ) 171 | ) 172 | return 173 | 174 | use_color = interactive 175 | col_w = 80 176 | 177 | for pkg in res.packages: 178 | header = ( 179 | (f"" f"") 180 | if use_color 181 | else f"{pkg.name}@{pkg.version}" 182 | ) 183 | 184 | desc = pkg.description or "" 185 | raw_len = len(pkg.name) + 1 + len(pkg.version) 186 | gap = " " * max(1, 32 - raw_len) 187 | wrapped = textwrap.wrap(desc, width=col_w - 32) 188 | 189 | first_line = f"{header}{gap}{esc(wrapped[0]) if wrapped else ''}" 190 | if use_color: 191 | print_formatted_text(HTML(first_line)) 192 | else: 193 | print(first_line) 194 | 195 | for w in wrapped[1:]: 196 | print(" " * 32 + w) 197 | 198 | url_chunk = f"" if use_color else pkg.url 199 | if use_color: 200 | print_formatted_text(HTML(" " * 32 + url_chunk)) 201 | else: 202 | print(" " * 32 + pkg.url) 203 | print() 204 | 205 | shown = len(res.packages) 206 | offset = self._opts.offset or 0 207 | earlier = offset 208 | later = max(res.total - (offset + shown), 0) 209 | 210 | if earlier or later: 211 | parts = [] 212 | if earlier: 213 | parts.append(f"{earlier} earlier") 214 | if later: 215 | parts.append(f"{later} more") 216 | print("… " + " and ".join(parts) + ". Use --limit and --offset to navigate through results.") 217 | 218 | def _cmd_install(self) -> None: 219 | pm = self._pm 220 | normalized_omits = self._normalize_omits(self._opts.omits) 221 | 222 | interactive = self._have_terminal and not self._plain_terminal 223 | 224 | if self._opts.quiet or not interactive: 225 | result = pm.install( 226 | project_root=self._opts.project_root, 227 | role=self._opts.role, 228 | specs=self._opts.specs, 229 | omits=normalized_omits, 230 | ) 231 | else: 232 | BAR_LEN = 30 233 | FG = ansi_fg(THEME_COLOR) 234 | RESET = Style.RESET_ALL 235 | start_time = time.time() 236 | 237 | bar_visible = False 238 | longest_vis = 0 239 | last_snapshot = None 240 | lock = threading.Lock() 241 | done = threading.Event() 242 | 243 | def render(phase: str, fraction: float, details: Optional[str]) -> None: 244 | nonlocal bar_visible, longest_vis, last_snapshot 245 | 246 | if details is not None: 247 | return 248 | 249 | with lock: 250 | last_snapshot = (phase, fraction, details) 251 | 252 | if not bar_visible and time.time() - start_time < SPINNER_DELAY: 253 | return 254 | bar_visible = True 255 | 256 | pct = int(fraction * 100) 257 | fill = int(fraction * BAR_LEN) 258 | bar = "█" * fill + " " * (BAR_LEN - fill) 259 | msg = phase.replace("-", " ") 260 | 261 | line = f"\r{FG}[{bar}]{RESET} {pct:3d}% {msg}" 262 | vis = len(ANSI_PATTERN.sub("", line)) - 1 263 | 264 | pad = " " * max(0, longest_vis - vis) 265 | longest_vis = max(longest_vis, vis) 266 | 267 | sys.stderr.write(line + pad) 268 | sys.stderr.flush() 269 | 270 | if phase == "complete": 271 | done.set() 272 | 273 | def watchdog() -> None: 274 | time.sleep(SPINNER_DELAY) 275 | with lock: 276 | snap = None if bar_visible else last_snapshot 277 | if snap is not None: 278 | render(*snap) 279 | 280 | pm.on("install-progress", render) 281 | threading.Thread(target=watchdog, daemon=True).start() 282 | 283 | try: 284 | result = pm.install( 285 | project_root=self._opts.project_root, 286 | role=self._opts.role, 287 | specs=self._opts.specs, 288 | omits=normalized_omits, 289 | ) 290 | finally: 291 | pm.off("install-progress", render) 292 | done.wait(0.05) 293 | if bar_visible: 294 | sys.stderr.write("\r" + " " * 80 + "\r") 295 | sys.stderr.flush() 296 | 297 | if self._opts.quiet: 298 | return 299 | 300 | if result.packages: 301 | for pkg in result.packages: 302 | print(f"✓ {pkg.name}@{pkg.version}") 303 | n = len(result.packages) 304 | package_or_packages = plural(n, "package") 305 | print(f"\n{n} {package_or_packages} installed into {os.path.abspath(self._opts.project_root)}") 306 | else: 307 | print("✔ up to date") 308 | 309 | def _normalize_omits(self, omits: Optional[List[str]]) -> Optional[List[str]]: 310 | if not omits: 311 | return omits 312 | normalized = [] 313 | for omit in omits: 314 | if omit == "dev": 315 | normalized.append("development") 316 | else: 317 | normalized.append(omit) 318 | return normalized 319 | 320 | 321 | def plural(n: int, word: str) -> str: 322 | return word if n == 1 else f"{word}s" 323 | 324 | 325 | def start_spinner(theme_hex: str) -> tuple[threading.Event, threading.Thread]: 326 | stop = threading.Event() 327 | frames = itertools.cycle("⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏") 328 | colour = ansi_fg(theme_hex) 329 | reset = Style.RESET_ALL 330 | 331 | def run() -> None: 332 | while not stop.is_set(): 333 | frame = next(frames) 334 | sys.stdout.write(f"\r{colour}{frame}{reset} Searching…") 335 | sys.stdout.flush() 336 | time.sleep(0.1) 337 | sys.stdout.write("\r" + " " * 40 + "\r") 338 | sys.stdout.flush() 339 | 340 | t = threading.Thread(target=run, daemon=True) 341 | t.start() 342 | return stop, t 343 | 344 | 345 | def esc(text: str) -> str: 346 | return html.escape(text, quote=False) 347 | 348 | 349 | def ansi_fg(hex_color: str) -> str: 350 | r, g, b = (int(hex_color[i : i + 2], 16) for i in (1, 3, 5)) 351 | return f"\x1b[38;2;{r};{g};{b}m" 352 | 353 | 354 | if __name__ == "__main__": 355 | try: 356 | main() 357 | except KeyboardInterrupt: 358 | pass 359 | -------------------------------------------------------------------------------- /frida_tools/ps.py: -------------------------------------------------------------------------------- 1 | def main() -> None: 2 | import argparse 3 | import functools 4 | import json 5 | import math 6 | import platform 7 | import sys 8 | from base64 import b64encode 9 | from typing import List, Tuple, Union 10 | 11 | try: 12 | import termios 13 | import tty 14 | except: 15 | pass 16 | 17 | import frida._frida as _frida 18 | 19 | from frida_tools.application import ConsoleApplication 20 | 21 | class PSApplication(ConsoleApplication): 22 | def _add_options(self, parser: argparse.ArgumentParser) -> None: 23 | parser.add_argument( 24 | "-a", 25 | "--applications", 26 | help="list only applications", 27 | action="store_true", 28 | dest="list_only_applications", 29 | default=False, 30 | ) 31 | parser.add_argument( 32 | "-i", 33 | "--installed", 34 | help="include all installed applications", 35 | action="store_true", 36 | dest="include_all_applications", 37 | default=False, 38 | ) 39 | parser.add_argument( 40 | "-j", 41 | "--json", 42 | help="output results as JSON", 43 | action="store_const", 44 | dest="output_format", 45 | const="json", 46 | default="text", 47 | ) 48 | parser.add_argument( 49 | "-e", 50 | "--exclude-icons", 51 | help="exclude icons in output", 52 | action="store_true", 53 | dest="exclude_icons", 54 | ) 55 | 56 | def _initialize(self, parser: argparse.ArgumentParser, options: argparse.Namespace, args: List[str]) -> None: 57 | if options.include_all_applications and not options.list_only_applications: 58 | parser.error("-i cannot be used without -a") 59 | self._list_only_applications = options.list_only_applications 60 | self._include_all_applications = options.include_all_applications 61 | self._output_format = options.output_format 62 | self._exclude_icons = options.exclude_icons 63 | self._terminal_type, self._icon_size = self._detect_terminal() 64 | 65 | def _usage(self) -> str: 66 | return "%(prog)s [options]" 67 | 68 | def _start(self) -> None: 69 | if self._list_only_applications: 70 | self._list_applications() 71 | else: 72 | self._list_processes() 73 | 74 | def _list_processes(self) -> None: 75 | if not self._exclude_icons and self._output_format == "text" and self._terminal_type == "iterm2": 76 | scope = "full" 77 | else: 78 | scope = "minimal" 79 | 80 | try: 81 | assert self._device is not None 82 | processes = self._device.enumerate_processes(scope=scope) 83 | except Exception as e: 84 | self._update_status(f"Failed to enumerate processes: {e}") 85 | self._exit(1) 86 | return 87 | 88 | if self._output_format == "text": 89 | if len(processes) > 0: 90 | pid_column_width = max(map(lambda p: len(str(p.pid)), processes)) 91 | icon_width = max(map(compute_icon_width, processes)) 92 | name_column_width = icon_width + max(map(lambda p: len(p.name), processes)) 93 | 94 | header_format = "%" + str(pid_column_width) + "s %s" 95 | self._print(header_format % ("PID", "Name")) 96 | self._print(f"{pid_column_width * '-'} {name_column_width * '-'}") 97 | 98 | line_format = "%" + str(pid_column_width) + "d %s" 99 | name_format = "%-" + str(name_column_width - icon_width) + "s" 100 | 101 | for process in sorted(processes, key=functools.cmp_to_key(compare_processes)): 102 | if icon_width != 0: 103 | icons = process.parameters.get("icons", None) 104 | if icons is not None: 105 | icon = self._render_icon(icons[0]) 106 | else: 107 | icon = " " 108 | name = icon + " " + name_format % process.name 109 | else: 110 | name = name_format % process.name 111 | 112 | self._print(line_format % (process.pid, name)) 113 | else: 114 | self._log("error", "No running processes.") 115 | elif self._output_format == "json": 116 | result = [] 117 | for process in sorted(processes, key=functools.cmp_to_key(compare_processes)): 118 | result.append({"pid": process.pid, "name": process.name}) 119 | self._print(json.dumps(result, sort_keys=False, indent=2)) 120 | 121 | self._exit(0) 122 | 123 | def _list_applications(self) -> None: 124 | if not self._exclude_icons and self._output_format == "text" and self._terminal_type == "iterm2": 125 | scope = "full" 126 | else: 127 | scope = "minimal" 128 | 129 | try: 130 | assert self._device is not None 131 | applications = self._device.enumerate_applications(scope=scope) 132 | except Exception as e: 133 | self._update_status(f"Failed to enumerate applications: {e}") 134 | self._exit(1) 135 | return 136 | 137 | if not self._include_all_applications: 138 | applications = list(filter(lambda app: app.pid != 0, applications)) 139 | 140 | if self._output_format == "text": 141 | if len(applications) > 0: 142 | pid_column_width = max(map(lambda app: len(str(app.pid)), applications)) 143 | icon_width = max(map(compute_icon_width, applications)) 144 | name_column_width = icon_width + max(map(lambda app: len(app.name), applications)) 145 | identifier_column_width = max(map(lambda app: len(app.identifier), applications)) 146 | 147 | header_format = ( 148 | "%" 149 | + str(pid_column_width) 150 | + "s " 151 | + "%-" 152 | + str(name_column_width) 153 | + "s " 154 | + "%-" 155 | + str(identifier_column_width) 156 | + "s" 157 | ) 158 | self._print(header_format % ("PID", "Name", "Identifier")) 159 | self._print(f"{pid_column_width * '-'} {name_column_width * '-'} {identifier_column_width * '-'}") 160 | 161 | line_format = "%" + str(pid_column_width) + "s %s %-" + str(identifier_column_width) + "s" 162 | name_format = "%-" + str(name_column_width - icon_width) + "s" 163 | 164 | for app in sorted(applications, key=functools.cmp_to_key(compare_applications)): 165 | if icon_width != 0: 166 | icons = app.parameters.get("icons", None) 167 | if icons is not None: 168 | icon = self._render_icon(icons[0]) 169 | else: 170 | icon = " " 171 | name = icon + " " + name_format % app.name 172 | else: 173 | name = name_format % app.name 174 | 175 | if app.pid == 0: 176 | self._print(line_format % ("-", name, app.identifier)) 177 | else: 178 | self._print(line_format % (app.pid, name, app.identifier)) 179 | 180 | elif self._include_all_applications: 181 | self._log("error", "No installed applications.") 182 | else: 183 | self._log("error", "No running applications.") 184 | elif self._output_format == "json": 185 | result = [] 186 | if len(applications) > 0: 187 | for app in sorted(applications, key=functools.cmp_to_key(compare_applications)): 188 | result.append({"pid": (app.pid or None), "name": app.name, "identifier": app.identifier}) 189 | self._print(json.dumps(result, sort_keys=False, indent=2)) 190 | 191 | self._exit(0) 192 | 193 | def _render_icon(self, icon) -> str: 194 | return "\033]1337;File=inline=1;width={}px;height={}px;:{}\007".format( 195 | self._icon_size, self._icon_size, b64encode(icon["image"]).decode("ascii") 196 | ) 197 | 198 | def _detect_terminal(self) -> Tuple[str, int]: 199 | icon_size = 0 200 | 201 | if not self._have_terminal or self._plain_terminal or platform.system() != "Darwin": 202 | return ("simple", icon_size) 203 | 204 | fd = sys.stdin.fileno() 205 | old_attributes = termios.tcgetattr(fd) 206 | try: 207 | tty.setraw(fd) 208 | new_attributes = termios.tcgetattr(fd) 209 | new_attributes[3] = new_attributes[3] & ~termios.ICANON & ~termios.ECHO 210 | termios.tcsetattr(fd, termios.TCSANOW, new_attributes) 211 | 212 | sys.stdout.write("\033[1337n") 213 | sys.stdout.write("\033[5n") 214 | sys.stdout.flush() 215 | 216 | response = self._read_terminal_response("n") 217 | if response not in ("0", "3"): 218 | self._read_terminal_response("n") 219 | 220 | if response.startswith("ITERM2 "): 221 | version_tokens = response.split(" ", 1)[1].split(".", 2) 222 | if len(version_tokens) >= 2 and int(version_tokens[0]) >= 3: 223 | sys.stdout.write("\033[14t") 224 | sys.stdout.flush() 225 | height_in_pixels = int(self._read_terminal_response("t").split(";")[1]) 226 | 227 | sys.stdout.write("\033[18t") 228 | sys.stdout.flush() 229 | height_in_cells = int(self._read_terminal_response("t").split(";")[1]) 230 | 231 | icon_size = math.ceil((height_in_pixels / height_in_cells) * 1.77) 232 | 233 | return ("iterm2", icon_size) 234 | 235 | return ("simple", icon_size) 236 | finally: 237 | termios.tcsetattr(fd, termios.TCSANOW, old_attributes) 238 | 239 | def _read_terminal_response(self, terminator: str) -> str: 240 | sys.stdin.read(1) 241 | sys.stdin.read(1) 242 | result = "" 243 | while True: 244 | ch = sys.stdin.read(1) 245 | if ch == terminator: 246 | break 247 | result += ch 248 | return result 249 | 250 | def compare_applications(a: _frida.Application, b: _frida.Application) -> int: 251 | a_is_running = a.pid != 0 252 | b_is_running = b.pid != 0 253 | if a_is_running == b_is_running: 254 | if a.name > b.name: 255 | return 1 256 | elif a.name < b.name: 257 | return -1 258 | else: 259 | return 0 260 | elif a_is_running: 261 | return -1 262 | else: 263 | return 1 264 | 265 | def compare_processes(a: _frida.Process, b: _frida.Process) -> int: 266 | a_has_icon = "icons" in a.parameters 267 | b_has_icon = "icons" in b.parameters 268 | if a_has_icon == b_has_icon: 269 | if a.name > b.name: 270 | return 1 271 | elif a.name < b.name: 272 | return -1 273 | else: 274 | return 0 275 | elif a_has_icon: 276 | return -1 277 | else: 278 | return 1 279 | 280 | def compute_icon_width(item: Union[_frida.Application, _frida.Process]) -> int: 281 | for icon in item.parameters.get("icons", []): 282 | if icon["format"] == "png": 283 | return 4 284 | return 0 285 | 286 | app = PSApplication() 287 | app.run() 288 | 289 | 290 | if __name__ == "__main__": 291 | try: 292 | main() 293 | except KeyboardInterrupt: 294 | pass 295 | -------------------------------------------------------------------------------- /apps/tracer/src/EventView.tsx: -------------------------------------------------------------------------------- 1 | import "./EventView.css"; 2 | import { DisassemblyTarget, Event, HandlerId } from "./model.js"; 3 | import { Button, Card } from "@blueprintjs/core"; 4 | import Ansi from "@curvenote/ansi-to-react"; 5 | import prettyMilliseconds from "pretty-ms"; 6 | import { ReactElement, useCallback, useEffect, useRef, useState } from "react"; 7 | import AutoSizer from "react-virtualized-auto-sizer"; 8 | import { VariableSizeList } from "react-window"; 9 | 10 | export interface EventViewProps { 11 | events: Event[]; 12 | selectedIndex: number | null; 13 | onActivate: EventActionHandler; 14 | onDeactivate: EventActionHandler; 15 | onDisassemble: DisassembleHandler; 16 | onSymbolicate: SymbolicateHandler; 17 | } 18 | 19 | export type EventActionHandler = (handlerId: HandlerId, eventIndex: number) => void; 20 | export type DisassembleHandler = (target: DisassemblyTarget) => void; 21 | export type SymbolicateHandler = (addresses: bigint[]) => Promise; 22 | 23 | const NON_BLOCKING_SPACE = "\u00A0"; 24 | const INDENT = NON_BLOCKING_SPACE.repeat(3) + "|" + NON_BLOCKING_SPACE; 25 | 26 | export default function EventView({ 27 | events, 28 | selectedIndex = null, 29 | onActivate, 30 | onDeactivate, 31 | onDisassemble, 32 | onSymbolicate, 33 | }: EventViewProps) { 34 | const listRef = useRef(null); 35 | const listOuterRef = useRef(null); 36 | const [items, setItems] = useState([]); 37 | const [selectedCallerSymbol, setSelectedCallerSymbol] = useState(""); 38 | const [selectedBacktraceSymbols, setSelectedBacktraceSymbols] = useState(null); 39 | const autoscroll = useRef({ enabled: true, pending: [] }); 40 | 41 | useEffect(() => { 42 | let lastTimestamp: number | null = null; 43 | let lastTid: number | null = null; 44 | const newItems = events.reduce((result, event, i) => { 45 | const ev = event.slice() as Event; 46 | const [_targetId, timestamp, threadId, _depth, _caller, _backtrace, _message, style] = ev; 47 | 48 | if (lastTimestamp !== null) { 49 | ev[1] = timestamp - lastTimestamp; 50 | } else { 51 | ev[1] = 0; 52 | } 53 | lastTimestamp = timestamp; 54 | 55 | if (threadId !== lastTid) { 56 | result.push([i, threadId, style]); 57 | lastTid = threadId; 58 | } 59 | 60 | result.push([i, ev]); 61 | return result; 62 | }, [[] as SpacerItem] as Item[]); 63 | setItems(newItems); 64 | 65 | let ignore = false; 66 | 67 | if (autoscroll.current.enabled) { 68 | autoscroll.current.pending.push(() => { 69 | if (!ignore) { 70 | listRef.current?.scrollToItem(newItems.length - 1, "end"); 71 | } 72 | }); 73 | } 74 | 75 | return () => { 76 | ignore = true; 77 | }; 78 | }, [events]); 79 | 80 | const itemSize = useCallback((i: number) => { 81 | const item = items[i]; 82 | 83 | if (item.length === 0) { 84 | return 5; 85 | } 86 | 87 | if (item.length === 3) { 88 | return 15.43; 89 | } 90 | 91 | const [eventIndex, event] = item; 92 | const [_targetId, _timestamp, _threadId, _depth, _caller, backtrace, message, _style] = event; 93 | const numLines = message.split("\n").length; 94 | let size = 30; 95 | if (numLines > 1) { 96 | size += (numLines - 1) * 14; 97 | size -= 7; 98 | } 99 | if (eventIndex === selectedIndex) { 100 | size += 150; 101 | if (backtrace !== null) { 102 | size += (backtrace.length - 1) * 34; 103 | } 104 | } 105 | return size; 106 | }, [items, selectedIndex]); 107 | 108 | useEffect(() => { 109 | setSelectedCallerSymbol(null); 110 | setSelectedBacktraceSymbols(null); 111 | 112 | const list = listRef.current; 113 | if (list !== null) { 114 | list.resetAfterIndex(0, true); 115 | if (selectedIndex !== null) { 116 | const itemIndex = items.findIndex(([i,]) => i === selectedIndex); 117 | list.scrollToItem(itemIndex); 118 | } 119 | } 120 | }, [selectedIndex]); 121 | 122 | useEffect(() => { 123 | if (selectedIndex === null) { 124 | return; 125 | } 126 | 127 | const [_targetId, _timestamp, _threadId, _depth, caller, backtrace, _message, _style] = events[selectedIndex]; 128 | let ignore = false; 129 | 130 | async function symbolicate() { 131 | if (caller !== null && backtrace === null) { 132 | const [symbol] = await onSymbolicate([BigInt(caller)]); 133 | if (!ignore) { 134 | setSelectedCallerSymbol(symbol); 135 | } 136 | } 137 | 138 | if (backtrace !== null) { 139 | const symbols = await onSymbolicate(backtrace.map(BigInt)); 140 | if (!ignore) { 141 | setSelectedBacktraceSymbols(symbols); 142 | } 143 | } 144 | } 145 | 146 | symbolicate(); 147 | 148 | return () => { 149 | ignore = true; 150 | }; 151 | }, [events, selectedIndex, onSymbolicate]); 152 | 153 | const handleDisassemblyRequest = useCallback((rawAddress: string) => { 154 | onDisassemble({ type: "instruction", address: BigInt(rawAddress) }); 155 | }, [onDisassemble]); 156 | 157 | return ( 158 | 159 | {({ width, height }) => ( 160 | 161 | ref={listRef} 162 | outerRef={listOuterRef} 163 | className="event-list" 164 | width={width} 165 | height={height} 166 | itemCount={items.length} 167 | itemSize={itemSize} 168 | itemData={items} 169 | onItemsRendered={() => { 170 | let work: AutoscrollWork | undefined; 171 | while ((work = autoscroll.current.pending.shift()) !== undefined) { 172 | work(); 173 | } 174 | }} 175 | onScroll={props => { 176 | if (!props.scrollUpdateWasRequested) { 177 | const container = listOuterRef.current!; 178 | autoscroll.current.enabled = container.scrollTop >= (container.scrollHeight - container.offsetHeight - 20); 179 | } 180 | }} 181 | > 182 | {({ data, index: itemIndex, style }) => { 183 | const item = data[itemIndex]; 184 | 185 | if (item.length === 0) { 186 | return ( 187 |

188 | ); 189 | } 190 | 191 | if (item.length === 3) { 192 | const [, threadId, textStyle] = item; 193 | const colorClass = "ansi-" + textStyle.join("-"); 194 | return ( 195 |

199 | /* TID 0x{threadId.toString(16)} */ 200 |

201 | ); 202 | } 203 | 204 | const [eventIndex, event] = item; 205 | const [targetId, timestamp, threadId, depth, caller, backtrace, message, textStyle] = event; 206 | 207 | const isSelected = eventIndex === selectedIndex; 208 | let selectedEventDetails: ReactElement | undefined; 209 | if (isSelected) { 210 | selectedEventDetails = ( 211 | 212 | 213 | 214 | 215 | 216 | 217 | 219 | 220 | {(caller !== null && backtrace === null) ? ( 221 | 222 | 223 | 226 | 227 | ) : null 228 | } 229 | {(backtrace !== null) ? ( 230 | 231 | 232 | 238 | 239 | ) : null 240 | } 241 | 242 |

Thread ID	0x{threadId.toString(16)}	218 \|
Caller	224 \| 225 \|
Backtrace	233 \| {backtrace.map((address, i) => 234 \| )} 237 \|

243 | 244 | 245 | ); 246 | } 247 | 248 | const eventClasses = ["event-item"]; 249 | if (isSelected) { 250 | eventClasses.push("event-selected"); 251 | } 252 | 253 | const timestampStr = (timestamp !== 0) ? `+${prettyMilliseconds(timestamp)}` : ""; 254 | 255 | const colorClass = "ansi-" + textStyle.join("-"); 256 | 257 | return ( 258 |

262 |

263 | {timestampStr} 264 | {INDENT.repeat(depth)} 265 | 273 |

274 | {isSelected ? selectedEventDetails : null} 275 |

276 | ); 277 | }} 278 | 279 | )} 280 | 281 | ); 282 | } 283 | 284 | type Item = EventItem | ThreadIdMarkerItem | SpacerItem; 285 | type EventItem = [index: number, event: Event]; 286 | type ThreadIdMarkerItem = [index: number, threadId: number, style: string[]]; 287 | type SpacerItem = []; 288 | 289 | interface AutoscrollState { 290 | enabled: boolean; 291 | pending: AutoscrollWork[]; 292 | } 293 | 294 | type AutoscrollWork = () => void; 295 | --------------------------------------------------------------------------------