@jshookmcp/jshook 0.2.8 → 0.2.9

package/dist/{Speedhack-CeF0XmEz.mjs → Speedhack-CqdIFlQl.mjs}

@@ -1,5 +1,5 @@
-import { _ as WriteProcessMemory, b as openProcessForMemory, c as GetProcAddress, d as ReadProcessMemory, f as VirtualAllocEx, l as MEM, m as VirtualProtectEx, o as GetModuleHandle, p as VirtualFreeEx, t as CloseHandle, u as PAGE } from "./Win32API-Bc0QnQsN.mjs";
-import { l as FlushInstructionCache } from "./Win32Debug-DUHt9XUn.mjs";
+import { _ as WriteProcessMemory, b as openProcessForMemory, c as GetProcAddress, d as ReadProcessMemory, f as VirtualAllocEx, l as MEM, m as VirtualProtectEx, o as GetModuleHandle, p as VirtualFreeEx, t as CloseHandle, u as PAGE } from "./Win32API-CePkipZY.mjs";
+import { l as FlushInstructionCache } from "./Win32Debug-BvKs-gxc.mjs";
 //#region src/native/Speedhack.ts
 var Speedhack = class {
 	states = /* @__PURE__ */ new Map();

package/dist/{StructureAnalyzer-D4GkMduU.mjs → StructureAnalyzer-DhFaPvRO.mjs}

@@ -1,6 +1,6 @@
-import { An as STRUCT_RTTI_MAX_STRING_LEN, jn as STRUCT_VTABLE_MAX_FUNCTIONS, kn as STRUCT_ANALYZE_DEFAULT_SIZE } from "./constants-CCvsN80K.mjs";
-import { t as nativeMemoryManager } from "./NativeMemoryManager.impl-CB6gJ0NM.mjs";
-import { t as createPlatformProvider } from "./factory-CibqTNC8.mjs";
+import { ir as STRUCT_VTABLE_MAX_FUNCTIONS, nr as STRUCT_ANALYZE_DEFAULT_SIZE, rr as STRUCT_RTTI_MAX_STRING_LEN } from "./constants-B0OANIBL.mjs";
+import { t as createPlatformProvider } from "./factory-DxlGh9Xf.mjs";
+import { t as nativeMemoryManager } from "./NativeMemoryManager.impl-dZtA1ZGn.mjs";
 //#region src/native/StructureAnalyzer.ts
 /**
 * Structure Analyzer — heuristic memory structure inference.

package/dist/ToolCatalog-C0JGZoOm.mjs

@@ -0,0 +1,582 @@
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+//#region src/server/registry/generated-domains.ts
+const generatedManifestLoaders = [
+	{
+		domain: "adb-bridge",
+		depKey: "adbBridgeHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-BqrQ4Tpj.mjs")
+	},
+	{
+		domain: "core",
+		depKey: "coreAnalysisHandlers",
+		profiles: ["workflow", "full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-DCyjf4n2.mjs")
+	},
+	{
+		domain: "antidebug",
+		depKey: "antidebugHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-CFADCRa1.mjs")
+	},
+	{
+		domain: "binary-instrument",
+		depKey: "binaryInstrumentHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-CAhOuvSl.mjs")
+	},
+	{
+		domain: "boringssl-inspector",
+		depKey: "boringsslInspectorHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-qSleDqdO.mjs")
+	},
+	{
+		domain: "browser",
+		depKey: "browserHandlers",
+		profiles: ["workflow", "full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-Br4RPFt5.mjs")
+	},
+	{
+		domain: "canvas",
+		depKey: "canvasHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-2ToTpjv8.mjs")
+	},
+	{
+		domain: "coordination",
+		depKey: "coordinationHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-BKbgbSiY.mjs")
+	},
+	{
+		domain: "cross-domain",
+		depKey: "crossDomainHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-CXsRWjjI.mjs")
+	},
+	{
+		domain: "debugger",
+		depKey: "debuggerHandlers",
+		profiles: ["workflow", "full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-CV12bcrF.mjs")
+	},
+	{
+		domain: "encoding",
+		depKey: "encodingHandlers",
+		profiles: ["workflow", "full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-Df_dliIe.mjs")
+	},
+	{
+		domain: "evidence",
+		depKey: "evidenceHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-3g71z6Bg.mjs")
+	},
+	{
+		domain: "extension-registry",
+		depKey: "extensionRegistryHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-gZ4s_UtG.mjs")
+	},
+	{
+		domain: "graphql",
+		depKey: "graphqlHandlers",
+		profiles: ["workflow", "full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-Bnd7kqEY.mjs")
+	},
+	{
+		domain: "hooks",
+		depKey: "aiHookHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: ["hookPresetHandlers"],
+		load: () => import("./manifest-DzwvxPJX.mjs")
+	},
+	{
+		domain: "instrumentation",
+		depKey: "instrumentationHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-D6phHKFd.mjs")
+	},
+	{
+		domain: "macro",
+		depKey: "macroHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-BmtZzQiQ2.mjs")
+	},
+	{
+		domain: "maintenance",
+		depKey: "coreMaintenanceHandlers",
+		profiles: ["workflow", "full"],
+		secondaryDepKeys: ["extensionManagementHandlers"],
+		load: () => import("./manifest-C5qDjysN.mjs")
+	},
+	{
+		domain: "memory",
+		depKey: "memoryScanHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-Sc_0JQ13.mjs")
+	},
+	{
+		domain: "mojo-ipc",
+		depKey: "mojoIpcHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-B3QVVeBS.mjs")
+	},
+	{
+		domain: "network",
+		depKey: "advancedHandlers",
+		profiles: ["workflow", "full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-DlpTj4ic2.mjs")
+	},
+	{
+		domain: "platform",
+		depKey: "platformHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-CZLUCfG02.mjs")
+	},
+	{
+		domain: "process",
+		depKey: "processHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-CQVhavRF.mjs")
+	},
+	{
+		domain: "protocol-analysis",
+		depKey: "protocolAnalysisHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-DrbmZcFl2.mjs")
+	},
+	{
+		domain: "proxy",
+		depKey: "proxyHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-BqQX6OQC2.mjs")
+	},
+	{
+		domain: "sandbox",
+		depKey: "sandboxHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-C9RT5nk32.mjs")
+	},
+	{
+		domain: "shared-state-board",
+		depKey: "sharedStateBoardHandlers",
+		profiles: ["workflow", "full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-CT7zZBV1.mjs")
+	},
+	{
+		domain: "skia-capture",
+		depKey: "skiaCaptureHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-Dh8WBmEW.mjs")
+	},
+	{
+		domain: "sourcemap",
+		depKey: "sourcemapHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-82baTv4U.mjs")
+	},
+	{
+		domain: "streaming",
+		depKey: "streamingHandlers",
+		profiles: ["workflow", "full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-CBYWCUBJ.mjs")
+	},
+	{
+		domain: "syscall-hook",
+		depKey: "syscallHookHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-BB2J8IMJ.mjs")
+	},
+	{
+		domain: "trace",
+		depKey: "traceHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-DhKRAT8_.mjs")
+	},
+	{
+		domain: "transform",
+		depKey: "transformHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-DHsnKgP6.mjs")
+	},
+	{
+		domain: "v8-inspector",
+		depKey: "v8InspectorHandlers",
+		profiles: ["workflow", "full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-Bcf-TJzH.mjs")
+	},
+	{
+		domain: "wasm",
+		depKey: "wasmHandlers",
+		profiles: ["full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-DuwHjUa5.mjs")
+	},
+	{
+		domain: "workflow",
+		depKey: "workflowHandlers",
+		profiles: ["workflow", "full"],
+		secondaryDepKeys: [],
+		load: () => import("./manifest-NXctwWQq.mjs")
+	}
+];
+/** Domains included in each profile tier (derived at build time from manifest sources). */
+const DOMAIN_PROFILE_MAP = {
+	"adb-bridge": ["full"],
+	"core": ["workflow", "full"],
+	"antidebug": ["full"],
+	"binary-instrument": ["full"],
+	"boringssl-inspector": ["full"],
+	"browser": ["workflow", "full"],
+	"canvas": ["full"],
+	"coordination": ["full"],
+	"cross-domain": ["full"],
+	"debugger": ["workflow", "full"],
+	"encoding": ["workflow", "full"],
+	"evidence": ["full"],
+	"extension-registry": ["full"],
+	"graphql": ["workflow", "full"],
+	"hooks": ["full"],
+	"instrumentation": ["full"],
+	"macro": ["full"],
+	"maintenance": ["workflow", "full"],
+	"memory": ["full"],
+	"mojo-ipc": ["full"],
+	"network": ["workflow", "full"],
+	"platform": ["full"],
+	"process": ["full"],
+	"protocol-analysis": ["full"],
+	"proxy": ["full"],
+	"sandbox": ["full"],
+	"shared-state-board": ["workflow", "full"],
+	"skia-capture": ["full"],
+	"sourcemap": ["full"],
+	"streaming": ["workflow", "full"],
+	"syscall-hook": ["full"],
+	"trace": ["full"],
+	"transform": ["full"],
+	"v8-inspector": ["workflow", "full"],
+	"wasm": ["full"],
+	"workflow": ["workflow", "full"]
+};
+//#endregion
+//#region src/server/registry/discovery.ts
+function isDomainManifest(value) {
+	if (!value || typeof value !== "object") return false;
+	const m = value;
+	return m["kind"] === "domain-manifest" && m["version"] === 1 && typeof m["domain"] === "string" && typeof m["depKey"] === "string" && Array.isArray(m["profiles"]) && Array.isArray(m["registrations"]) && typeof m["ensure"] === "function";
+}
+function extractManifest(mod) {
+	if (!mod || typeof mod !== "object") return null;
+	const m = mod;
+	for (const key of [
+		"default",
+		"manifest",
+		"domainManifest"
+	]) {
+		const candidate = m[key];
+		if (isDomainManifest(candidate)) return candidate;
+	}
+	return null;
+}
+/** Return the set of domain names that belong to a given profile tier. */
+function getDomainsForProfile(profile) {
+	const result = /* @__PURE__ */ new Set();
+	for (const [domain, profiles] of Object.entries(DOMAIN_PROFILE_MAP)) if (profiles.includes(profile)) result.add(domain);
+	return result;
+}
+/** Return ALL known domain names from build-time metadata (no loading required). */
+function getAllKnownDomainNames() {
+	return new Set(Object.keys(DOMAIN_PROFILE_MAP));
+}
+/** Return the full loader metadata array (no loading). */
+function getLoaderMetadata() {
+	return generatedManifestLoaders;
+}
+/**
+* Load manifests for a specific set of domains.
+* Skips domains that fail validation with a warning.
+*/
+async function discoverDomainManifests(domainsToLoad) {
+	const manifests = [];
+	const seenDomains = /* @__PURE__ */ new Set();
+	const seenDepKeys = /* @__PURE__ */ new Set();
+	for (const { domain: domainName, load } of generatedManifestLoaders) {
+		if (domainsToLoad && !domainsToLoad.has(domainName)) continue;
+		try {
+			const manifest = extractManifest(await load());
+			if (!manifest) {
+				logger.warn(`[discovery] Skipping domain "${domainName}": no valid DomainManifest export`);
+				continue;
+			}
+			if (seenDomains.has(manifest.domain)) {
+				logger.warn("[discovery] Duplicate domain \"" + manifest.domain + "\" in generated manifests - skipping");
+				continue;
+			}
+			if (seenDepKeys.has(manifest.depKey)) {
+				logger.warn("[discovery] Duplicate depKey \"" + manifest.depKey + "\" in generated manifests - skipping");
+				continue;
+			}
+			seenDomains.add(manifest.domain);
+			seenDepKeys.add(manifest.depKey);
+			manifests.push(manifest);
+			logger.info("[discovery] Loaded domain \"" + manifest.domain + "\" (" + String(manifest.registrations.length) + " tools)");
+		} catch (err) {
+			logger.error(`[discovery] Failed to load domain "${domainName}"`, err);
+			if (process.env.DISCOVERY_STRICT === "true") throw err;
+		}
+	}
+	const totalTools = manifests.reduce((n, m) => n + m.registrations.length, 0);
+	logger.info("[discovery] Discovered " + String(manifests.length) + " domains, " + String(totalTools) + " tools total");
+	return manifests;
+}
+/**
+* Load a single domain manifest by name.
+* Returns null if the domain doesn't exist or fails validation.
+*/
+async function loadSingleManifest(domainName) {
+	const loader = generatedManifestLoaders.find((l) => l.domain === domainName);
+	if (!loader) return null;
+	try {
+		const manifest = extractManifest(await loader.load());
+		if (!manifest) {
+			logger.warn(`[discovery] Domain "${domainName}": no valid DomainManifest export`);
+			return null;
+		}
+		logger.info("[discovery] On-demand loaded domain \"" + manifest.domain + "\" (" + String(manifest.registrations.length) + " tools)");
+		return manifest;
+	} catch (err) {
+		logger.error(`[discovery] Failed to load domain "${domainName}"`, err);
+		return null;
+	}
+}
+//#endregion
+//#region src/server/registry/index.ts
+/**
+* Central tool registry — single source of truth with lazy domain loading.
+*
+* Startup loads only manifests for the active profile tier.
+* Additional domains are loaded on-demand via ensureDomainLoaded().
+*/
+function isSubset(a, b) {
+	const bSet = new Set(b);
+	return a.every((x) => bSet.has(x));
+}
+let _manifests = null;
+let _registrations = null;
+let _initPromise = null;
+let _domainsView = null;
+let _toolNamesView = null;
+let _registrationsByName = null;
+async function init(profile) {
+	if (_manifests !== null) return;
+	if (_initPromise) {
+		await _initPromise;
+		return;
+	}
+	_initPromise = (async () => {
+		const discovered = await discoverDomainManifests(profile ? getDomainsForProfile(profile) : void 0);
+		_manifests = discovered;
+		_registrationsByName = /* @__PURE__ */ new Map();
+		for (const m of discovered) for (const r of m.registrations) {
+			const registration = r.domain ? r : {
+				...r,
+				domain: m.domain
+			};
+			const existing = _registrationsByName.get(registration.tool.name);
+			if (existing) logger.warn(`[registry] Duplicate tool name "${registration.tool.name}": domain "${registration.domain}" conflicts with "${existing.domain}" — keeping first`);
+			else _registrationsByName.set(registration.tool.name, registration);
+		}
+		_registrations = [..._registrationsByName.values()];
+		_domainsView = new Set(_manifests.map((m) => m.domain));
+		_toolNamesView = new Set(_registrations.map((r) => r.tool.name));
+	})();
+	await _initPromise;
+}
+async function initRegistry(profile) {
+	await init(profile);
+}
+/**
+* Ensure a single domain's manifest is loaded.
+* Loads the manifest, adds its registrations, and updates cached views.
+* Returns the manifest or null if loading failed.
+*/
+async function ensureDomainLoaded(domainName) {
+	if (!_manifests) throw new Error("[registry] Not initialised - call initRegistry() first.");
+	if (_manifests.some((m) => m.domain === domainName)) return _manifests.find((m) => m.domain === domainName);
+	const manifest = await loadSingleManifest(domainName);
+	if (!manifest) return null;
+	_manifests.push(manifest);
+	_domainsView.add(manifest.domain);
+	for (const r of manifest.registrations) {
+		const registration = r.domain ? r : {
+			...r,
+			domain: manifest.domain
+		};
+		if (!_registrationsByName.has(registration.tool.name)) _registrationsByName.set(registration.tool.name, registration);
+	}
+	_registrations = [..._registrationsByName.values()];
+	for (const r of manifest.registrations) _toolNamesView.add(r.tool.name);
+	return manifest;
+}
+/**
+* Ensure ALL domain manifests are loaded.
+* Useful for search_tools which needs to index all tools.
+* No-op if all domains are already loaded.
+*/
+async function ensureAllDomainsLoaded() {
+	if (!_manifests) throw new Error("[registry] Not initialised - call initRegistry() first.");
+	const allDomains = getAllKnownDomainNames();
+	const loaded = new Set(_manifests.map((m) => m.domain));
+	const missing = [...allDomains].filter((d) => !loaded.has(d));
+	if (missing.length === 0) return;
+	logger.info(`[registry] Loading ${missing.length} remaining domains for full discovery`);
+	await Promise.all(missing.map((d) => ensureDomainLoaded(d)));
+}
+function getManifests() {
+	if (!_manifests) throw new Error("[registry] Not initialised - call initRegistry() first.");
+	return _manifests;
+}
+function getRegistrations() {
+	if (!_registrations) throw new Error("[registry] Not initialised - call initRegistry() first.");
+	return _registrations;
+}
+function getAllManifests() {
+	return getManifests();
+}
+function getAllRegistrations() {
+	return getRegistrations();
+}
+/** Returns domain names of LOADED manifests only. */
+function getAllDomains() {
+	if (!_domainsView) throw new Error("[registry] Not initialised - call initRegistry() first.");
+	return _domainsView;
+}
+/** Returns ALL known domain names from build-time metadata (no loading needed). */
+function getAllKnownDomains() {
+	return getAllKnownDomainNames();
+}
+function buildToolGroups() {
+	const groups = {};
+	for (const r of getRegistrations()) (groups[r.domain] ??= []).push(r.tool);
+	return groups;
+}
+function buildToolDomainMap() {
+	const map = /* @__PURE__ */ new Map();
+	for (const r of getRegistrations()) if (!map.has(r.tool.name)) map.set(r.tool.name, r.domain);
+	return map;
+}
+function buildAllTools() {
+	return getRegistrations().map((r) => r.tool);
+}
+function buildHandlerMapFromRegistry(deps, selectedToolNames) {
+	const regs = selectedToolNames ? getRegistrations().filter((r) => selectedToolNames.has(r.tool.name)) : [...getRegistrations()];
+	const entries = [];
+	for (const r of regs) try {
+		entries.push([r.tool.name, r.bind(deps)]);
+	} catch {}
+	return Object.fromEntries(entries);
+}
+function buildProfileDomains() {
+	const profiles = {
+		search: /* @__PURE__ */ new Set(),
+		workflow: /* @__PURE__ */ new Set(),
+		full: /* @__PURE__ */ new Set()
+	};
+	for (const [domain, domainProfiles] of Object.entries(DOMAIN_PROFILE_MAP)) for (const p of domainProfiles) profiles[p]?.add(domain);
+	const result = {};
+	for (const [p, domains] of Object.entries(profiles)) result[p] = [...domains];
+	if (!isSubset(result["search"], result["workflow"])) logger.warn("[registry] Profile hierarchy: search not subset of workflow");
+	if (!isSubset(result["workflow"], result["full"])) logger.warn("[registry] Profile hierarchy: workflow not subset of full");
+	return result;
+}
+//#endregion
+//#region src/server/ToolCatalog.ts
+let _toolGroups = null;
+let _toolDomainByName = null;
+let _profileDomains = null;
+let _allTools = null;
+function getToolGroups() {
+	if (!_toolGroups) _toolGroups = buildToolGroups();
+	return _toolGroups;
+}
+function getToolDomainByName() {
+	if (!_toolDomainByName) _toolDomainByName = buildToolDomainMap();
+	return _toolDomainByName;
+}
+function getProfileDomainsMap() {
+	if (!_profileDomains) _profileDomains = buildProfileDomains();
+	return _profileDomains;
+}
+const allTools = new Proxy([], { get(_t, p) {
+	if (!_allTools) _allTools = buildAllTools();
+	const real = _allTools;
+	const v = real[p];
+	return typeof v === "function" ? v.bind(real) : v;
+} });
+function dedupeTools(tools) {
+	const map = /* @__PURE__ */ new Map();
+	for (const tool of tools) map.set(tool.name, tool);
+	return Array.from(map.values());
+}
+function parseToolDomains(raw) {
+	if (!raw?.trim()) return null;
+	const validDomains = getAllDomains();
+	const parsed = raw.split(",").map((item) => item.trim().toLowerCase()).filter(Boolean).filter((item) => validDomains.has(item));
+	return parsed.length > 0 ? Array.from(new Set(parsed)) : null;
+}
+function getToolsByDomains(domains) {
+	return dedupeTools(domains.flatMap((domain) => getToolGroups()[domain] ?? []));
+}
+function getToolsForProfile(profile) {
+	const domains = getProfileDomainsMap()[profile];
+	if (!domains) return [];
+	const domainSet = new Set(domains);
+	return dedupeTools([...getAllRegistrations()].filter((r) => {
+		if (!domainSet.has(r.domain)) return false;
+		if (r.profiles && !r.profiles.includes(profile)) return false;
+		return true;
+	}).map((r) => r.tool));
+}
+function getToolDomain(toolName) {
+	return getToolDomainByName().get(toolName) ?? null;
+}
+function getProfileDomains(profile) {
+	return getProfileDomainsMap()[profile] ?? [];
+}
+//#endregion
+export { getToolsForProfile as a, ensureAllDomainsLoaded as c, getAllKnownDomains as d, getAllManifests as f, getLoaderMetadata as h, getToolsByDomains as i, ensureDomainLoaded as l, initRegistry as m, getProfileDomains as n, parseToolDomains as o, getAllRegistrations as p, getToolDomain as r, buildHandlerMapFromRegistry as s, allTools as t, getAllDomains as u };

package/dist/ToolError-jh9whhMd.mjs

@@ -0,0 +1,15 @@
+//#region src/errors/ToolError.ts
+var ToolError = class extends Error {
+	code;
+	toolName;
+	details;
+	constructor(code, message, options) {
+		super(message, { cause: options?.cause });
+		this.name = "ToolError";
+		this.code = code;
+		this.toolName = options?.toolName;
+		this.details = options?.details;
+	}
+};
+//#endregion
+export { ToolError as t };

package/dist/ToolProbe-oC7aPrkv.mjs

@@ -0,0 +1,45 @@
+import "./logger-Dh_xb7_2.mjs";
+import { J as EXTERNAL_TOOL_PROBE_TIMEOUT_MS } from "./constants-B0OANIBL.mjs";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region src/modules/external/ToolProbe.ts
+/**
+* Tool availability probe.
+* Detects whether external CLI tools are available on the system.
+*/
+const execFileAsync = promisify(execFile);
+/**
+* Check if a command exists and optionally extract its version.
+*/
+async function probeCommand(command, versionArgs = ["--version"], timeoutMs = EXTERNAL_TOOL_PROBE_TIMEOUT_MS) {
+	try {
+		const { stdout: pathOutput } = await execFileAsync(process.platform === "win32" ? "where" : "which", [command], {
+			timeout: timeoutMs,
+			windowsHide: true
+		});
+		const resolvedPath = pathOutput.trim().split(/\r?\n/)[0];
+		let version;
+		try {
+			const { stdout: versionOutput } = await execFileAsync(command, versionArgs, {
+				timeout: timeoutMs,
+				windowsHide: true
+			});
+			const firstLine = versionOutput.trim().split(/\r?\n/)[0];
+			version = firstLine ? firstLine.substring(0, 100) : void 0;
+		} catch {}
+		return {
+			available: true,
+			path: resolvedPath,
+			version
+		};
+	} catch (err) {
+		const errorCode = typeof err === "object" && err !== null && "code" in err ? err.code : void 0;
+		const errorMessage = err instanceof Error ? err.message : typeof err === "object" && err !== null && "message" in err ? String(err.message ?? "") : String(err ?? "");
+		return {
+			available: false,
+			reason: errorCode === "ENOENT" ? `Command '${command}' not found in PATH` : `Probe failed: ${errorMessage.substring(0, 200)}`
+		};
+	}
+}
+//#endregion
+export { probeCommand as t };