javaperf 1.0.0

package/dist/tools/heap_dump.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export declare const heapDumpSchema: z.ZodObject<{
+    pid: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    pid: number;
+}, {
+    pid: number;
+}>;
+export type HeapDumpInput = z.infer<typeof heapDumpSchema>;
+export declare function heapDump(input: HeapDumpInput): Promise<string>;

package/dist/tools/heap_dump.js

@@ -0,0 +1,29 @@
+import { existsSync, mkdirSync, statSync } from "node:fs";
+import { z } from "zod";
+import { runJcmd } from "../utils/jdk.js";
+import { RECORDINGS_DIR } from "../utils/paths.js";
+import { join } from "node:path";
+export const heapDumpSchema = z.object({
+    pid: z.number().int().positive(),
+});
+const HEAP_DUMP_PATH = join(RECORDINGS_DIR, "heap_dump.hprof");
+export async function heapDump(input) {
+    const { pid } = input;
+    if (!existsSync(RECORDINGS_DIR)) {
+        mkdirSync(RECORDINGS_DIR, { recursive: true });
+    }
+    runJcmd(pid, "GC.heap_dump", [`filename=${HEAP_DUMP_PATH}`]);
+    if (!existsSync(HEAP_DUMP_PATH)) {
+        return JSON.stringify({
+            status: "error",
+            message: "Heap dump command completed but file was not found.",
+        });
+    }
+    const stats = statSync(HEAP_DUMP_PATH);
+    return JSON.stringify({
+        filepath: HEAP_DUMP_PATH,
+        fileSize: stats.size,
+        status: "saved",
+        hint: "Open in Eclipse MAT, VisualVM, or JProfiler for analysis. File can be large (hundreds of MB - GB).",
+    }, null, 2);
+}

package/dist/tools/heap_histogram.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export declare const heapHistogramSchema: z.ZodObject<{
+    pid: z.ZodNumber;
+    topN: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    all: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    topN: number;
+    pid: number;
+    all: boolean;
+}, {
+    pid: number;
+    topN?: number | undefined;
+    all?: boolean | undefined;
+}>;
+export type HeapHistogramInput = z.infer<typeof heapHistogramSchema>;
+export declare function heapHistogram(input: HeapHistogramInput): Promise<string>;

package/dist/tools/heap_histogram.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { runJcmd } from "../utils/jdk.js";
+export const heapHistogramSchema = z.object({
+    pid: z.number().int().positive(),
+    topN: z.number().int().min(1).max(200).optional().default(20),
+    all: z.boolean().optional().default(false),
+});
+function parseHistogramOutput(output) {
+    const lines = output.trim().split("\n");
+    const result = [];
+    for (const line of lines) {
+        const match = line.match(/^\s*\d+:\s+(\d+)\s+(\d+)\s+(.+)$/);
+        if (!match)
+            continue;
+        const instances = parseInt(match[1], 10);
+        const bytes = parseInt(match[2], 10);
+        const className = match[3].trim();
+        result.push({ className, instances, bytes });
+    }
+    result.sort((a, b) => b.bytes - a.bytes);
+    return result;
+}
+export async function heapHistogram(input) {
+    const { pid, topN, all } = input;
+    const opts = all ? ["-all"] : [];
+    const output = runJcmd(pid, "GC.class_histogram", opts);
+    const entries = parseHistogramOutput(output);
+    const top = entries.slice(0, topN);
+    return JSON.stringify({ entries: top, total: entries.length }, null, 2);
+}

package/dist/tools/heap_info.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export declare const heapInfoSchema: z.ZodObject<{
+    pid: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    pid: number;
+}, {
+    pid: number;
+}>;
+export type HeapInfoInput = z.infer<typeof heapInfoSchema>;
+export declare function heapInfo(input: HeapInfoInput): Promise<string>;

package/dist/tools/heap_info.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { runJcmd } from "../utils/jdk.js";
+export const heapInfoSchema = z.object({
+    pid: z.number().int().positive(),
+});
+export async function heapInfo(input) {
+    const { pid } = input;
+    const output = runJcmd(pid, "GC.heap_info");
+    return output.trim();
+}

package/dist/tools/list_procs.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export declare const listJavaProcessesSchema: z.ZodObject<{
+    topN: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    topN: number;
+}, {
+    topN?: number | undefined;
+}>;
+export type ListJavaProcessesInput = z.infer<typeof listJavaProcessesSchema>;
+export declare function listJavaProcesses(input: ListJavaProcessesInput): Promise<string>;

package/dist/tools/list_procs.js

@@ -0,0 +1,11 @@
+import { z } from "zod";
+import { runJps } from "../utils/jdk.js";
+export const listJavaProcessesSchema = z.object({
+    topN: z.number().int().min(1).max(100).optional().default(10),
+});
+export async function listJavaProcesses(input) {
+    const { topN } = input;
+    const processes = runJps();
+    const limited = processes.slice(0, topN);
+    return JSON.stringify(limited, null, 2);
+}

package/dist/tools/parse_jfr.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export declare const parseJfrSummarySchema: z.ZodObject<{
+    filepath: z.ZodString;
+    events: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    topN: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    topN: number;
+    filepath: string;
+    events?: string[] | undefined;
+}, {
+    filepath: string;
+    topN?: number | undefined;
+    events?: string[] | undefined;
+}>;
+export type ParseJfrSummaryInput = z.infer<typeof parseJfrSummarySchema>;
+export declare function parseJfrSummary(input: ParseJfrSummaryInput): Promise<string>;

package/dist/tools/parse_jfr.js

@@ -0,0 +1,64 @@
+import { z } from "zod";
+import { existsSync } from "node:fs";
+import { runJfr } from "../utils/jdk.js";
+import { resolveProfilePath } from "../utils/paths.js";
+import { getEvents, getEventType, getStackTrace, getMethodKey } from "../utils/jfr-json.js";
+export const parseJfrSummarySchema = z.object({
+    filepath: z.string(),
+    events: z.array(z.string()).optional(),
+    topN: z.number().int().min(1).max(100).optional().default(10),
+});
+export async function parseJfrSummary(input) {
+    const { topN } = input;
+    const filepath = resolveProfilePath(input.filepath);
+    if (!existsSync(filepath)) {
+        return JSON.stringify({ error: `File not found: ${filepath}` });
+    }
+    const events = input.events ?? [
+        "jdk.ExecutionSample",
+        "jdk.GarbageCollection",
+        "jdk.JavaThreadStatistics",
+        "jdk.ThreadAllocationStatistics",
+    ];
+    const eventsArg = events.join(",");
+    const [summaryOut, jsonOut] = await Promise.all([
+        runJfr(["summary", filepath]),
+        runJfr(["print", "--json", "--events", eventsArg, filepath]),
+    ]);
+    const methodCount = new Map();
+    let gcCount = 0;
+    const anomalies = [];
+    try {
+        const parsed = JSON.parse(jsonOut);
+        const eventsList = getEvents(parsed);
+        for (const ev of eventsList) {
+            const typ = getEventType(ev);
+            if (typ === "jdk.GarbageCollection")
+                gcCount++;
+            if (typ === "jdk.ExecutionSample") {
+                const frames = getStackTrace(ev)?.frames ?? [];
+                for (const f of frames) {
+                    const key = getMethodKey(f);
+                    if (key)
+                        methodCount.set(key, (methodCount.get(key) ?? 0) + 1);
+                }
+            }
+        }
+        if (gcCount > 100)
+            anomalies.push("High GC count - possible memory pressure");
+    }
+    catch {
+        // continue with summary only
+    }
+    const topMethods = [...methodCount.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, topN)
+        .map(([m, c]) => ({ method: m, samples: c }));
+    const result = {
+        summary: summaryOut.trim(),
+        topMethods,
+        gcStats: { gcEvents: gcCount },
+        anomalies: anomalies.length ? anomalies : undefined,
+    };
+    return JSON.stringify(result, null, 2);
+}

package/dist/tools/profile_frequency.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const profileFrequencySchema: z.ZodObject<{
+    filepath: z.ZodString;
+    topN: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    topN: number;
+    filepath: string;
+}, {
+    filepath: string;
+    topN?: number | undefined;
+}>;
+export type ProfileFrequencyInput = z.infer<typeof profileFrequencySchema>;
+export declare function profileFrequency(input: ProfileFrequencyInput): Promise<string>;

package/dist/tools/profile_frequency.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { existsSync } from "node:fs";
+import { runJfr } from "../utils/jdk.js";
+import { resolveProfilePath } from "../utils/paths.js";
+import { getEvents, getStackTrace, getMethodKey } from "../utils/jfr-json.js";
+export const profileFrequencySchema = z.object({
+    filepath: z.string(),
+    topN: z.number().int().min(1).max(100).optional().default(10),
+});
+export async function profileFrequency(input) {
+    const { topN } = input;
+    const filepath = resolveProfilePath(input.filepath);
+    if (!existsSync(filepath)) {
+        return JSON.stringify({ error: `File not found: ${filepath}` });
+    }
+    const output = await runJfr(["print", "--json", "--events", "jdk.ExecutionSample", filepath]);
+    const leafCount = new Map();
+    try {
+        const parsed = JSON.parse(output);
+        const eventsList = getEvents(parsed);
+        for (const ev of eventsList) {
+            const frames = getStackTrace(ev)?.frames ?? [];
+            const leaf = frames[0];
+            if (leaf) {
+                const key = getMethodKey(leaf);
+                if (key)
+                    leafCount.set(key, (leafCount.get(key) ?? 0) + 1);
+            }
+        }
+    }
+    catch {
+        return JSON.stringify({ error: "Failed to parse JFR ExecutionSample output." });
+    }
+    const top = [...leafCount.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, topN)
+        .map(([method, samples]) => ({ method, samples, note: "exclusive (leaf frame)" }));
+    return JSON.stringify({ profile: "frequency", topMethods: top }, null, 2);
+}

package/dist/tools/profile_memory.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const profileMemorySchema: z.ZodObject<{
+    filepath: z.ZodString;
+    topN: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    topN: number;
+    filepath: string;
+}, {
+    filepath: string;
+    topN?: number | undefined;
+}>;
+export type ProfileMemoryInput = z.infer<typeof profileMemorySchema>;
+export declare function profileMemory(input: ProfileMemoryInput): Promise<string>;

package/dist/tools/profile_memory.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { existsSync } from "node:fs";
+import { runJfr } from "../utils/jdk.js";
+import { resolveProfilePath } from "../utils/paths.js";
+import { getEvents, getEventType, getStackTrace, getMethodKey } from "../utils/jfr-json.js";
+export const profileMemorySchema = z.object({
+    filepath: z.string(),
+    topN: z.number().int().min(1).max(100).optional().default(10),
+});
+const MEMORY_EVENTS = [
+    "jdk.ObjectAllocationInNewTLAB",
+    "jdk.ObjectAllocationOutsideTLAB",
+    "jdk.ObjectAllocationSample",
+    "jdk.OldObjectSample",
+    "jdk.GarbageCollection",
+    "jdk.HeapSummary",
+].join(",");
+export async function profileMemory(input) {
+    const { topN } = input;
+    const filepath = resolveProfilePath(input.filepath);
+    if (!existsSync(filepath)) {
+        return JSON.stringify({ error: `File not found: ${filepath}` });
+    }
+    const output = await runJfr(["print", "--json", "--events", MEMORY_EVENTS, filepath]);
+    const allocatorCount = new Map();
+    let gcCount = 0;
+    const potentialLeaks = [];
+    try {
+        const parsed = JSON.parse(output);
+        const eventsList = getEvents(parsed);
+        for (const ev of eventsList) {
+            const typ = getEventType(ev);
+            if (typ === "jdk.GarbageCollection")
+                gcCount++;
+            const stackTrace = getStackTrace(ev);
+            const frames = stackTrace?.frames;
+            if ((typ === "jdk.ObjectAllocationInNewTLAB" ||
+                typ === "jdk.ObjectAllocationOutsideTLAB" ||
+                typ === "jdk.ObjectAllocationSample") &&
+                frames?.length) {
+                const top = frames[0];
+                const key = getMethodKey(top);
+                if (key && key !== "unknown")
+                    allocatorCount.set(key, (allocatorCount.get(key) ?? 0) + 1);
+            }
+            if (typ === "jdk.OldObjectSample" && frames?.length) {
+                const top = frames[0];
+                const key = getMethodKey(top);
+                if (key)
+                    potentialLeaks.push(key);
+            }
+        }
+    }
+    catch {
+        return JSON.stringify({ error: "Failed to parse JFR output. Ensure recording used settings=profile." });
+    }
+    const topAllocators = [...allocatorCount.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, topN)
+        .map(([allocator, count]) => ({ allocator, count }));
+    const result = {
+        topAllocators,
+        gcStats: { gcEvents: gcCount },
+        potentialLeaks: potentialLeaks.length ? [...new Set(potentialLeaks)].slice(0, 5) : undefined,
+    };
+    return JSON.stringify(result, null, 2);
+}

package/dist/tools/profile_time.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const profileTimeSchema: z.ZodObject<{
+    filepath: z.ZodString;
+    topN: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    topN: number;
+    filepath: string;
+}, {
+    filepath: string;
+    topN?: number | undefined;
+}>;
+export type ProfileTimeInput = z.infer<typeof profileTimeSchema>;
+export declare function profileTime(input: ProfileTimeInput): Promise<string>;

package/dist/tools/profile_time.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { existsSync } from "node:fs";
+import { runJfr } from "../utils/jdk.js";
+import { resolveProfilePath } from "../utils/paths.js";
+import { getEvents, getStackTrace, getMethodKey } from "../utils/jfr-json.js";
+export const profileTimeSchema = z.object({
+    filepath: z.string(),
+    topN: z.number().int().min(1).max(100).optional().default(10),
+});
+export async function profileTime(input) {
+    const { topN } = input;
+    const filepath = resolveProfilePath(input.filepath);
+    if (!existsSync(filepath)) {
+        return JSON.stringify({ error: `File not found: ${filepath}` });
+    }
+    const output = await runJfr(["print", "--json", "--events", "jdk.ExecutionSample", filepath]);
+    const methodSamples = new Map();
+    try {
+        const parsed = JSON.parse(output);
+        const eventsList = getEvents(parsed);
+        for (const ev of eventsList) {
+            const frames = getStackTrace(ev)?.frames ?? [];
+            for (const f of frames) {
+                const key = getMethodKey(f);
+                if (key)
+                    methodSamples.set(key, (methodSamples.get(key) ?? 0) + 1);
+            }
+        }
+    }
+    catch {
+        return JSON.stringify({ error: "Failed to parse JFR ExecutionSample output." });
+    }
+    const top = [...methodSamples.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, topN)
+        .map(([method, samples]) => ({ method, samples, note: "cumulative CPU time (incl. callees)" }));
+    return JSON.stringify({ profile: "time", topMethods: top }, null, 2);
+}

package/dist/tools/start_profiling.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const startProfilingSchema: z.ZodObject<{
+    pid: z.ZodNumber;
+    duration: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    pid: number;
+    duration: number;
+}, {
+    pid: number;
+    duration: number;
+}>;
+export type StartProfilingInput = z.infer<typeof startProfilingSchema>;
+export declare function startProfiling(input: StartProfilingInput): Promise<string>;

package/dist/tools/start_profiling.js

@@ -0,0 +1,36 @@
+import { existsSync, mkdirSync, renameSync, unlinkSync } from "node:fs";
+import { z } from "zod";
+import { runJcmd } from "../utils/jdk.js";
+import { NEW_PROFILE_PATH, OLD_PROFILE_PATH, RECORDINGS_DIR, } from "../utils/paths.js";
+export const startProfilingSchema = z.object({
+    pid: z.number().int().positive(),
+    duration: z.number().int().positive(),
+});
+function rotateProfiles() {
+    if (!existsSync(RECORDINGS_DIR)) {
+        mkdirSync(RECORDINGS_DIR, { recursive: true });
+        return;
+    }
+    if (existsSync(OLD_PROFILE_PATH)) {
+        unlinkSync(OLD_PROFILE_PATH);
+    }
+    if (existsSync(NEW_PROFILE_PATH)) {
+        renameSync(NEW_PROFILE_PATH, OLD_PROFILE_PATH);
+    }
+}
+export async function startProfiling(input) {
+    const { pid, duration } = input;
+    rotateProfiles();
+    const cmd = `JFR.start duration=${duration}s settings=profile`;
+    const output = runJcmd(pid, cmd);
+    const match = output.match(/Started recording (\d+)\./);
+    const recordingId = match ? match[1] : "1";
+    return JSON.stringify({
+        recordingId,
+        status: "started",
+        message: output.trim(),
+        expiryTime: `in ${duration} seconds`,
+        newProfilePath: NEW_PROFILE_PATH,
+        oldProfilePath: OLD_PROFILE_PATH,
+    }, null, 2);
+}

package/dist/tools/stop_profiling.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const stopProfilingSchema: z.ZodObject<{
+    pid: z.ZodNumber;
+    recordingId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    pid: number;
+    recordingId: string;
+}, {
+    pid: number;
+    recordingId: string;
+}>;
+export type StopProfilingInput = z.infer<typeof stopProfilingSchema>;
+export declare function stopProfiling(input: StopProfilingInput): Promise<string>;

package/dist/tools/stop_profiling.js

@@ -0,0 +1,30 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { statSync } from "node:fs";
+import { z } from "zod";
+import { runJcmd } from "../utils/jdk.js";
+import { NEW_PROFILE_PATH, RECORDINGS_DIR } from "../utils/paths.js";
+export const stopProfilingSchema = z.object({
+    pid: z.number().int().positive(),
+    recordingId: z.string(),
+});
+export async function stopProfiling(input) {
+    const { pid, recordingId } = input;
+    if (!existsSync(RECORDINGS_DIR)) {
+        mkdirSync(RECORDINGS_DIR, { recursive: true });
+    }
+    runJcmd(pid, "JFR.stop", [`name=${recordingId}`, `filename=${NEW_PROFILE_PATH}`]);
+    if (!existsSync(NEW_PROFILE_PATH)) {
+        return JSON.stringify({
+            status: "error",
+            message: "Recording stopped but file was not found. Check JFR output.",
+        });
+    }
+    const stats = statSync(NEW_PROFILE_PATH);
+    return JSON.stringify({
+        filepath: NEW_PROFILE_PATH,
+        fileSize: stats.size,
+        status: "saved",
+        oldProfilePath: "recordings/old_profile.jfr (previous recording)",
+        hint: "Use recordings/new_profile.jfr for current, recordings/old_profile.jfr for previous (before/after comparison)",
+    }, null, 2);
+}

package/dist/tools/trace_method.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+export declare const traceMethodSchema: z.ZodObject<{
+    filepath: z.ZodString;
+    className: z.ZodString;
+    methodName: z.ZodString;
+    events: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    topN: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    topN: number;
+    filepath: string;
+    className: string;
+    methodName: string;
+    events?: string[] | undefined;
+}, {
+    filepath: string;
+    className: string;
+    methodName: string;
+    topN?: number | undefined;
+    events?: string[] | undefined;
+}>;
+export type TraceMethodInput = z.infer<typeof traceMethodSchema>;
+export declare function traceMethod(input: TraceMethodInput): Promise<string>;

package/dist/tools/trace_method.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { existsSync } from "node:fs";
+import { runJfr } from "../utils/jdk.js";
+import { resolveProfilePath } from "../utils/paths.js";
+import { getEvents, getStackTrace, getMethodKey } from "../utils/jfr-json.js";
+export const traceMethodSchema = z.object({
+    filepath: z.string(),
+    className: z.string(),
+    methodName: z.string(),
+    events: z.array(z.string()).optional(),
+    topN: z.number().int().min(1).max(100).optional().default(10),
+});
+export async function traceMethod(input) {
+    const { className, methodName, topN } = input;
+    const filepath = resolveProfilePath(input.filepath);
+    if (!existsSync(filepath)) {
+        return JSON.stringify({ error: `File not found: ${filepath}` });
+    }
+    const events = input.events ?? ["jdk.ExecutionSample"];
+    const eventsArg = events.join(",");
+    const output = await runJfr(["print", "--json", "--events", eventsArg, filepath]);
+    let eventsList;
+    try {
+        const parsed = JSON.parse(output);
+        eventsList = getEvents(parsed);
+    }
+    catch {
+        return JSON.stringify({ error: "Failed to parse JFR JSON output" });
+    }
+    const targetMethod = `${className}.${methodName}`;
+    const matchingPaths = new Map();
+    const classNorm = className.replace(/\//g, ".");
+    for (const ev of eventsList) {
+        const frames = getStackTrace(ev)?.frames ?? [];
+        const pathParts = [];
+        let found = false;
+        for (const f of frames) {
+            const fullMethod = getMethodKey(f);
+            if (fullMethod)
+                pathParts.push(fullMethod);
+            if (fullMethod.includes(classNorm) && fullMethod.includes(methodName)) {
+                found = true;
+            }
+        }
+        if (found && pathParts.length > 0) {
+            const path = pathParts.join(" <- ");
+            matchingPaths.set(path, (matchingPaths.get(path) ?? 0) + 1);
+        }
+    }
+    if (matchingPaths.size === 0) {
+        return `Method ${targetMethod} not found in ExecutionSample. Try a longer recording or ensure the method is invoked during profiling.`;
+    }
+    const sorted = [...matchingPaths.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, topN);
+    const lines = sorted.map(([path, count], i) => `${i + 1}. [${count}x] ${path}`);
+    return "Call tree (top paths where method appears):\n\n" + lines.join("\n");
+}

package/dist/tools/vm_info.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export declare const vmInfoSchema: z.ZodObject<{
+    pid: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    pid: number;
+}, {
+    pid: number;
+}>;
+export type VmInfoInput = z.infer<typeof vmInfoSchema>;
+export declare function vmInfo(input: VmInfoInput): Promise<string>;

package/dist/tools/vm_info.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import { runJcmd } from "../utils/jdk.js";
+export const vmInfoSchema = z.object({
+    pid: z.number().int().positive(),
+});
+export async function vmInfo(input) {
+    const { pid } = input;
+    const [uptimeOut, versionOut, flagsOut] = [
+        runJcmd(pid, "VM.uptime"),
+        runJcmd(pid, "VM.version"),
+        runJcmd(pid, "VM.flags"),
+    ];
+    const result = {
+        uptime: uptimeOut.trim(),
+        version: versionOut.trim(),
+        flags: flagsOut.trim(),
+    };
+    return JSON.stringify(result, null, 2);
+}

package/dist/utils/jdk.d.ts

@@ -0,0 +1,17 @@
+export interface JavaProcess {
+    pid: number;
+    mainClass: string;
+    args: string;
+}
+/**
+ * Run jps -l -m and parse output into structured process list.
+ */
+export declare function runJps(): JavaProcess[];
+/**
+ * Run jcmd with given pid and command.
+ */
+export declare function runJcmd(pid: number, command: string, options?: string[]): string;
+/**
+ * Run jfr command (print, summary, etc.) and return stdout.
+ */
+export declare function runJfr(args: string[]): Promise<string>;