Sharphy
Server Configuration
Describes the environment variables required to run the server.
| Name | Required | Description | Default |
|---|---|---|---|
| DOTNET_SYSTEM_GLOBALIZATION_INVARIANT | No | Ensures globalization invariant mode runs smoothly on Debian slim | 1 |
Instructions
Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.
This server publishes no instructions, or was last inspected before Glama recorded them.
Capabilities
Features and capabilities supported by this server
Protocol revision2025-11-25
| Capability | Details |
|---|---|
| tools | {} |
Tools
Functions exposed to the LLM to take actions
| Name | Description |
|---|---|
| sharphy_analyze_dumpA | Performs automated Root Cause Analysis (RCA) on Windows (.dmp) and Linux (ELF core dump) crash dumps. Use this tool when diagnosing fatal process crashes, unhandled exceptions, or crashing thread call stacks. Do NOT use for thread deadlock cycles (use 'sharphy_deadlock_detector') or heap memory leaks (use 'sharphy_inspect_heap'). This is a non-destructive, read-only diagnostic inspection. |
| sharphy_inspect_heapA | Inspects managed heap allocations, generation sizes (Gen 0/1/2, LOH, POH), fragmentation, and object leak retainers in a memory dump. Use this tool when diagnosing high memory usage, memory leaks, or OutOfMemoryException. Do NOT use for general crash RCA (use 'sharphy_analyze_dump') or thread lock cycles (use 'sharphy_deadlock_detector'). Non-destructive, read-only inspection. |
| sharphy_deadlock_detectorA | Detects thread synchronization deadlocks and lock contention by traversing CLR SyncBlocks and building a Wait-For Graph (WFG). Use this tool when diagnosing unresponsive or frozen .NET applications suspected of thread lock cycles. Do NOT use for unhandled exception crashes (use 'sharphy_analyze_dump') or heap analysis (use 'sharphy_inspect_heap'). Non-destructive, read-only inspection. |
| sharphy_decompile_methodA | Decompiles compiled CIL bytecode into idiomatic C# source code using the embedded ILSpy engine. Use this tool when inspecting method logic, lambda expressions, or async state machines of a compiled assembly. Do NOT use for metadata enumeration (use 'sharphy_inspect_metadata') or binary diffing (use 'sharphy_diff_assemblies'). Read-only inspection. |
| sharphy_diff_assembliesA | Compares two versions of a compiled .NET assembly at the ECMA-335 metadata level to identify added/removed types, API breaking changes, and CIL instruction size shifts. Use this tool when validating library updates, regression testing, or detecting API modifications. Do NOT use for decompiling full method bodies (use 'sharphy_decompile_method'). Read-only comparison. |
| sharphy_inspect_metadataA | Decodes ECMA-335 metadata tables including TypeDef, MethodDef, FieldDef, custom attributes, P/Invoke imports, and embedded resources. Use this tool when discovering types and member signatures of an assembly without decompiling method bodies. Do NOT use for binary comparisons (use 'sharphy_diff_assemblies'). Read-only inspection. |
| sharphy_clean_obfuscationA | Demangles control flow flattening (CFG demangling), trims dead code and excessive NOP sleds, and analyzes dynamic proxy delegates. Use this tool when reverse engineering obfuscated assemblies to produce a cleaner assembly for analysis. Do NOT use for direct opcode modification (use 'sharphy_patch_il'). Mutates by creating a cleaned assembly at outputPath. |
| sharphy_extract_tokensA | Safely extracts runtime tokens and types by loading target assemblies inside an isolated collectible AssemblyLoadContext (isCollectible: true). Use this tool when dynamically inspecting types without locking files on disk or polluting the host runtime. Do NOT use for static disassembly without runtime loading (use 'sharphy_inspect_metadata'). Sandboxed read-only execution. |
| sharphy_patch_ilA | Surgically modifies CIL bytecode instructions by replacing target opcodes, adjusting branch targets, and emitting a patched binary. Use this tool when bypassing validation logic, inserting NOP sleds, or altering execution flow. Do NOT use for general obfuscation stripping (use 'sharphy_clean_obfuscation'). Mutates by writing a patched assembly to outputPath. |
| sharphy_generate_wrapperA | Generates strongly-typed C# wrapper source code utilizing .NET 8+ [UnsafeAccessor] attributes to access private members and fields with zero reflection overhead. Use this tool when testing or accessing inaccessible internal/private APIs. Do NOT use for bytecode modification (use 'sharphy_patch_il'). Mutates disk by writing a new C# (.cs) source file to outputPath. |
Prompts
Interactive templates invoked by user choice
| Name | Description |
|---|---|
No prompts | |
Resources
Contextual data attached and managed by the client
| Name | Description |
|---|---|
No resources | |
TDQS
Scored across 10 tools
Each tool targets a clearly distinct artifact or diagnostic concern (crash dumps, heap, deadlocks, bytecode decompilation, metadata, assembly diffing, obfuscation, runtime token extraction, IL patching, wrapper generation). Descriptions even include explicit 'Do NOT use X, use Y' cross-references, eliminating plausible confusion between close pairs like inspect_metadata vs extract_tokens or clean_obfuscation vs patch_il.
All tools share the sharphy_ prefix and nearly all follow a verb_noun pattern (analyze_dump, inspect_heap, decompile_method, diff_assemblies, patch_il). The single outlier is sharphy_deadlock_detector, which is noun-based rather than an imperative verb, but it remains readable and predictable.
Ten tools is well within the ideal range and each maps to a distinct reverse-engineering or diagnostics workflow stage. No tool appears redundant or padded.
The surface covers the core lifecycle of dump analysis, static inspection, runtime reflection, diffing, and mutation (patching, obfuscation cleanup, wrapper generation). Minor gaps exist: no live-process attach/inspection, no assembly discovery/enumeration or type-search tool, and no way to execute or invoke a method after patching.