glimmervoid 0.0.0-stage → 0.30.0

package/dist/chunks/grok-DuU8xVLZ.js

@@ -0,0 +1,436 @@
+import { o as relayPath } from "./runtime-paths-Ci_ksSkj.js";
+import { n as AGENT_URL_ENV } from "./session-Cez8aIWg.js";
+import { t as HOOK_URL_ENV } from "./hook-relay-core-BHfYFnYV.js";
+import { a as SANE_YOLO_PATH_ENV, n as RTK_PATH_ENV, o as saneYoloEnv } from "./rtk-hook-core-Bl6gYHPN.js";
+import { t as buildHookCommand } from "./hook-command-core-DclEoE9e.js";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+//#region session/core/spawn-env.ts
+var GLIMMERVOID_SCRUB_KEYS = [
+	"GLIMMERVOID_PORT",
+	"GLIMMERVOID_CONFIG",
+	HOOK_URL_ENV,
+	AGENT_URL_ENV,
+	RTK_PATH_ENV,
+	SANE_YOLO_PATH_ENV,
+	...[
+		"GLIMMERVOID_POSTHOG_API_KEY",
+		"GLIMMERVOID_TELEGRAM_BOT_TOKEN",
+		"GLIMMERVOID_CLAUDE_OAUTH_TOKEN"
+	]
+];
+var SANE_YOLO_GUARD_KEYS = [SANE_YOLO_PATH_ENV, ...Object.keys(saneYoloEnv(""))];
+var SAFETY_NET_ENV_PREFIXES = ["CC_SAFETY_NET_", "SAFETY_NET_"];
+var LAUNCHING_TERMINAL_IDENTITY_KEYS = ["TERM_PROGRAM", "TERM_PROGRAM_VERSION"];
+function normalizePathEntry(entry) {
+	return entry.replace(/\\/g, "/").toLowerCase();
+}
+function isWindowsDriveColon(value, index, entryStart) {
+	if (path.delimiter !== ":") return false;
+	if (index !== entryStart + 1) return false;
+	if (!/[A-Za-z]/.test(value[index - 1] || "")) return false;
+	return value[index + 1] === "\\" || value[index + 1] === "/";
+}
+function splitPathEntries(value) {
+	const entries = [];
+	let entryStart = 0;
+	for (let index = 0; index < value.length; index += 1) {
+		if (value[index] !== path.delimiter) continue;
+		if (isWindowsDriveColon(value, index, entryStart)) continue;
+		entries.push(value.slice(entryStart, index));
+		entryStart = index + 1;
+	}
+	entries.push(value.slice(entryStart));
+	return entries.filter(Boolean);
+}
+function prependPathDir(env, prependPathDirValue) {
+	if (!prependPathDirValue) return;
+	const pathKey = Object.keys(env).find((key) => key.toLowerCase() === "path") || "PATH";
+	const existingPath = env[pathKey] || "";
+	const pathEntries = splitPathEntries(existingPath);
+	const normalizedPrependDir = normalizePathEntry(prependPathDirValue);
+	if (pathEntries.some((entry) => normalizePathEntry(entry) === normalizedPrependDir)) return;
+	if (!existingPath) {
+		env[pathKey] = prependPathDirValue;
+		return;
+	}
+	env[pathKey] = `${prependPathDirValue}${path.delimiter}${existingPath}`;
+}
+function isSafetyNetKey(key) {
+	const upperKey = key.toUpperCase();
+	return SAFETY_NET_ENV_PREFIXES.some((prefix) => upperKey.startsWith(prefix));
+}
+function isSaneYoloGuarded(extraEnv) {
+	if (!extraEnv) return false;
+	return SANE_YOLO_GUARD_KEYS.some((key) => extraEnv[key] !== void 0);
+}
+function scrubInheritedSafetyNetEnv(env) {
+	for (const key of Object.keys(env)) if (isSafetyNetKey(key)) delete env[key];
+}
+function buildAgentEnv(baseEnv, extraEnv, profile, { prependPathDir: pathDir = null } = {}) {
+	const env = { ...baseEnv };
+	for (const key of profile.scrub || []) delete env[key];
+	for (const key of GLIMMERVOID_SCRUB_KEYS) delete env[key];
+	for (const key of LAUNCHING_TERMINAL_IDENTITY_KEYS) delete env[key];
+	if (isSaneYoloGuarded(extraEnv)) scrubInheritedSafetyNetEnv(env);
+	Object.assign(env, extraEnv || {});
+	Object.assign(env, profile.set || {});
+	prependPathDir(env, pathDir);
+	return env;
+}
+//#endregion
+//#region session/core/grok-hooks-file-core.ts
+function hookGroup(command) {
+	return [{ hooks: [{
+		type: "command",
+		command
+	}] }];
+}
+function renderGrokHooksFile({ relayPath, events, hookToolRelayPath }) {
+	const hooks = {};
+	for (const event of events) {
+		const command = buildHookCommand(relayPath, event);
+		if (!command) return null;
+		hooks[event] = hookGroup(command);
+	}
+	if (hookToolRelayPath) {
+		const command = buildHookCommand(hookToolRelayPath, "saneYolo");
+		if (!command) return null;
+		hooks.PreToolUse = hookGroup(command);
+	}
+	return `${JSON.stringify({ hooks }, null, 2)}\n`;
+}
+function hasOnlyKeys(value, expectedKeys) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const actualKeys = Object.keys(value).sort();
+	const sortedExpectedKeys = [...expectedKeys].sort();
+	return actualKeys.length === sortedExpectedKeys.length && actualKeys.every((key, index) => key === sortedExpectedKeys[index]);
+}
+var MANAGED_RELAY_RE = /(?:^|\/)(hook-relay|hook-tool-relay)\.(?:js|ts)$/;
+function isManagedCommand(command, event) {
+	if (typeof command !== "string") return false;
+	const match = command.match(/^node (?:(?:"([^"\r\n]+)")|([^\s"']+)) ([A-Za-z][A-Za-z0-9_-]{0,63})$/);
+	if (!match) return false;
+	const relayPath = match[1] || match[2];
+	const relayMatch = relayPath.match(MANAGED_RELAY_RE);
+	if (!relayMatch) return false;
+	const expectedRelay = event === "PreToolUse" ? "hook-tool-relay" : "hook-relay";
+	const expectedToken = event === "PreToolUse" ? "saneYolo" : event;
+	if (relayMatch[1] !== expectedRelay || match[3] !== expectedToken) return false;
+	return buildHookCommand(relayPath, expectedToken) === command;
+}
+function isManagedHookGroup(group, event) {
+	if (!Array.isArray(group) || group.length !== 1) return false;
+	const matcherGroup = group[0];
+	if (!hasOnlyKeys(matcherGroup, ["hooks"])) return false;
+	if (!Array.isArray(matcherGroup.hooks) || matcherGroup.hooks.length !== 1) return false;
+	const handler = matcherGroup.hooks[0];
+	if (!hasOnlyKeys(handler, ["type", "command"])) return false;
+	if (handler.type !== "command") return false;
+	return isManagedCommand(handler.command, event);
+}
+function classifyGrokHooksFile(contents, { relayPath, events, managedEventSets = [], hookToolRelayPath }) {
+	if (contents == null) return "absent";
+	if (contents === renderGrokHooksFile({
+		relayPath,
+		events,
+		hookToolRelayPath
+	})) return "current";
+	if (contents === renderGrokHooksFile({
+		relayPath,
+		events
+	})) return "current";
+	let parsed = null;
+	try {
+		parsed = JSON.parse(contents);
+	} catch {
+		return "foreign";
+	}
+	if (!hasOnlyKeys(parsed, ["hooks"])) return "foreign";
+	const hooksValue = parsed.hooks;
+	if (hooksValue === null || hooksValue === void 0) throw new TypeError("hooks must be an object");
+	if (typeof hooksValue !== "object" || Array.isArray(hooksValue)) return "foreign";
+	const actualEvents = Object.keys(hooksValue);
+	if (!hasOnlyKeys(hooksValue, actualEvents)) return "foreign";
+	const hooks = hooksValue;
+	if (![events, ...managedEventSets].some((managedEvents) => hasOnlyKeys(hooks, managedEvents) || hasOnlyKeys(hooks, [...managedEvents, "PreToolUse"]))) return "foreign";
+	for (const event of actualEvents) if (!isManagedHookGroup(hooks[event], event)) return "foreign";
+	return "managed-stale";
+}
+var CIRCLE_HALVES_SPINNER_CODEPOINTS = /* @__PURE__ */ new Set([
+	9680,
+	9681,
+	9682,
+	9683
+]);
+function isBrailleChar(char) {
+	if (!char) return false;
+	const codePoint = char.codePointAt(0) ?? 0;
+	return codePoint >= 10240 && codePoint <= 10495;
+}
+function isSpinnerChar(char) {
+	if (!char) return false;
+	if (isBrailleChar(char)) return true;
+	return CIRCLE_HALVES_SPINNER_CODEPOINTS.has(char.codePointAt(0) ?? 0);
+}
+function isPathLikeTitle(title) {
+	return title.includes("/") || title.includes("\\");
+}
+function firstCharOfTitle(title) {
+	if (title.length === 0) return "";
+	return String.fromCodePoint(title.codePointAt(0) ?? 0);
+}
+function classifyAgentTitle(title, { cwdBasename = null }, vocabulary) {
+	const trimmedTitle = title.trim();
+	if (vocabulary.busyTitle && trimmedTitle === vocabulary.busyTitle) return "working";
+	if (vocabulary.idleTitle && trimmedTitle === vocabulary.idleTitle) return "ready";
+	if (isPathLikeTitle(title)) return "ignore";
+	if (vocabulary.isSpinnerChar(firstCharOfTitle(title))) return "working";
+	if (!cwdBasename) return "ignore";
+	const cwdAwareClassification = vocabulary.classifyAgainstCwdBasename?.(title, cwdBasename) ?? null;
+	if (cwdAwareClassification) return cwdAwareClassification;
+	if (trimmedTitle === cwdBasename) return "ready";
+	return "unknown";
+}
+//#endregion
+//#region session/adapters/grok.ts
+var ID = "grok";
+var COMMAND_NAME = "grok";
+var RELAY_PATH = relayPath("hook-relay");
+var HOOK_TOOL_RELAY_PATH = relayPath("hook-tool-relay");
+var HOOK_EVENTS = [
+	"UserPromptSubmit",
+	"Stop",
+	"StopFailure",
+	"StopCancelled",
+	"Notification",
+	"SubagentStart",
+	"SubagentStop"
+];
+var MANAGED_HOOK_EVENT_SETS = [[
+	"UserPromptSubmit",
+	"Stop",
+	"StopFailure",
+	"StopCancelled",
+	"Notification"
+]];
+var ACTION_REQUIRED_MARKER = String.fromCodePoint(9888);
+var CLAUDE_COMPAT_HOOKS_ENV = "GROK_CLAUDE_HOOKS_ENABLED";
+var PROJECT_CONFIG_CANDIDATES = Object.freeze([Object.freeze({
+	relPath: ".claude/settings.json",
+	presenceIsHit: false
+}), Object.freeze({
+	relPath: ".claude/settings.local.json",
+	presenceIsHit: false
+})]);
+var envProfile = {
+	scrub: [],
+	set: { [CLAUDE_COMPAT_HOOKS_ENV]: "false" }
+};
+function notificationType(payload) {
+	return String(payload?.notificationType || payload?.notification_type || "").toLowerCase();
+}
+function isMainSessionPayload(payload) {
+	return !payload?.subagentType && !payload?.subagent_type;
+}
+function mapBackgroundTask(task) {
+	if (!task || typeof task !== "object" || Array.isArray(task)) return task;
+	const entry = task;
+	return {
+		...entry,
+		...typeof entry.agentType === "string" ? { agent_type: entry.agentType } : {}
+	};
+}
+function mapHookPayload(_event, payload) {
+	if (!payload || typeof payload !== "object" || Array.isArray(payload)) return payload;
+	return {
+		...payload,
+		...typeof payload.subagentId === "string" ? { agent_id: payload.subagentId } : {},
+		...typeof payload.subagentType === "string" ? { agent_type: payload.subagentType } : {},
+		...Array.isArray(payload.backgroundTasks) ? { background_tasks: payload.backgroundTasks.map(mapBackgroundTask) } : {}
+	};
+}
+function mayContributeHooks(configText) {
+	if (typeof configText !== "string") return false;
+	let settings;
+	try {
+		settings = JSON.parse(configText);
+	} catch {
+		return true;
+	}
+	if (!settings || typeof settings !== "object" || Array.isArray(settings)) return false;
+	return Object.hasOwn(settings, "hooks");
+}
+function mapHookToSignal(event, payload) {
+	const normalizedEvent = String(event || "").toLowerCase();
+	if (normalizedEvent === "subagentstart") return "subagent-start";
+	if (normalizedEvent === "subagentstop") return "subagent-stop";
+	if (!isMainSessionPayload(payload)) return null;
+	switch (normalizedEvent) {
+		case "sessionstart": return "session-start";
+		case "sessionend": return "session-end";
+		case "userpromptsubmit": return "resume";
+		case "stop": return payload?.reason === "end_turn" ? "ready" : null;
+		case "stopfailure":
+		case "stopcancelled": return "ready";
+		case "notification": {
+			const type = notificationType(payload);
+			if (type === "idle_prompt") return "ready";
+			if (type === "permission_prompt" || type === "approval_required") return "awaiting-input";
+			return null;
+		}
+		default: return null;
+	}
+}
+function mapHookConfidence(event, payload) {
+	if (String(event || "").toLowerCase() === "notification" && notificationType(payload) === "idle_prompt") return "low";
+	return null;
+}
+function mapHookPromptKind(event, payload) {
+	if (String(event || "").toLowerCase() !== "notification") return null;
+	const type = notificationType(payload);
+	if (type === "permission_prompt" || type === "approval_required") return "permission";
+	return null;
+}
+function sessionIdOf(payload) {
+	return payload?.sessionId;
+}
+function classifyTitle(title) {
+	const normalizedTitle = String(title || "");
+	if (isPathLikeTitle(normalizedTitle)) return "ignore";
+	if (isBrailleChar(firstCharOfTitle(normalizedTitle))) return "working";
+	if (normalizedTitle.startsWith(ACTION_REQUIRED_MARKER)) return "awaiting-input";
+	return "unknown";
+}
+var titleProfile = {
+	classifyTitle,
+	taskTitle: {
+		readsTranscriptTitle: false,
+		genericTitles: [ID],
+		agentSuffix: ` - ${ID}`
+	}
+};
+function grokHome(env = process.env, homedir = os.homedir(), platform = process.platform) {
+	const pathApi = platform === "win32" ? path.win32 : path;
+	const configuredHome = typeof env.GROK_HOME === "string" ? env.GROK_HOME.trim() : "";
+	if (configuredHome) return pathApi.resolve(configuredHome);
+	return pathApi.join(homedir, ".grok");
+}
+function hooksFilePath(env = process.env, homedir = os.homedir()) {
+	return path.join(grokHome(env, homedir), "hooks", "glimmervoid.json");
+}
+function nativeBinaryPath({ platform = process.platform, env = process.env, homedir = os.homedir() } = {}) {
+	const pathApi = platform === "win32" ? path.win32 : path;
+	const binaryName = platform === "win32" ? "grok.exe" : "grok";
+	return pathApi.join(grokHome(env, homedir, platform), "bin", binaryName);
+}
+function resolveCommand({ platform = process.platform, env = process.env, homedir = os.homedir(), existsSync = fs.existsSync, realpathSync = fs.realpathSync, warn = console.warn } = {}) {
+	const candidate = nativeBinaryPath({
+		platform,
+		env,
+		homedir
+	});
+	try {
+		if (existsSync(candidate)) return {
+			path: realpathSync(candidate),
+			kind: "exe"
+		};
+	} catch (error) {
+		warn(`[glimmervoid] could not resolve the native 'grok' binary at ${candidate}: ${error instanceof Error ? error.message : String(error)}`);
+		return {
+			path: null,
+			kind: "unresolved"
+		};
+	}
+	warn(`[glimmervoid] could not resolve the native 'grok' binary at ${candidate}`);
+	return {
+		path: null,
+		kind: "unresolved"
+	};
+}
+function buildSpawnCommand({ resolved, settingsArgs = [], agentArgs = [] }) {
+	if (!resolved?.path) throw new Error("the native grok binary is not resolved");
+	return {
+		file: resolved.path,
+		args: [...settingsArgs, ...agentArgs]
+	};
+}
+function buildEnv(baseEnv, extraEnv, options) {
+	return buildAgentEnv(baseEnv, extraEnv, envProfile, options);
+}
+function buildArgs({ dangerouslySkipPermissions = false, resumeSessionId = null, extraArgs = [], initialPrompt = null } = {}) {
+	const args = ["--no-auto-update"];
+	if (dangerouslySkipPermissions) args.push("--always-approve");
+	if (resumeSessionId) args.push("-r", resumeSessionId);
+	if (extraArgs.length > 0) args.push(...extraArgs);
+	if (initialPrompt != null) args.push(initialPrompt);
+	return args;
+}
+var grok = {
+	id: ID,
+	label: "Grok Build",
+	usageVendor: "grok",
+	commandName: COMMAND_NAME,
+	envProfile,
+	titleProfile,
+	hooks: {
+		mapSignal: mapHookToSignal,
+		mapConfidence: mapHookConfidence,
+		mapPromptKind: mapHookPromptKind,
+		mapPayload: mapHookPayload,
+		injection: {
+			kind: "home-hooks-file",
+			filePath: hooksFilePath,
+			expectedContents: () => renderGrokHooksFile({
+				relayPath: RELAY_PATH,
+				events: HOOK_EVENTS,
+				hookToolRelayPath: HOOK_TOOL_RELAY_PATH
+			}),
+			classifyContents: (contents) => classifyGrokHooksFile(contents, {
+				relayPath: RELAY_PATH,
+				events: HOOK_EVENTS,
+				managedEventSets: MANAGED_HOOK_EVENT_SETS,
+				hookToolRelayPath: HOOK_TOOL_RELAY_PATH
+			}),
+			projectConfigCandidates: PROJECT_CONFIG_CANDIDATES,
+			mayContributeHooks
+		}
+	},
+	resolveCommand,
+	buildSpawnCommand,
+	buildEnv,
+	buildArgs,
+	sessionIdOf,
+	mapHookPayload,
+	mapHookToSignal,
+	mapHookConfidence,
+	mapHookPromptKind,
+	classifyTitle,
+	grokHome,
+	hooksFilePath,
+	nativeBinaryPath,
+	mayContributeHooks,
+	PROJECT_CONFIG_CANDIDATES,
+	CLAUDE_COMPAT_HOOKS_ENV,
+	HOOK_TOOL_RELAY_PATH,
+	HOOK_EVENTS,
+	MANAGED_HOOK_EVENT_SETS,
+	RELAY_PATH,
+	ACTION_REQUIRED_MARKER,
+	capabilities: {
+		hooks: true,
+		awaitingInput: true,
+		backgroundAgents: true,
+		resume: true,
+		statusLine: false,
+		rtk: false,
+		saneYolo: true,
+		antiSlop: false,
+		compactQuiet: false,
+		skipPermissionsFlag: true,
+		headless: true
+	}
+};
+//#endregion
+export { classifyGrokHooksFile as a, isSpinnerChar as i, classifyAgentTitle as n, renderGrokHooksFile as o, isBrailleChar as r, buildAgentEnv as s, grok as t };

package/dist/chunks/hook-command-core-DclEoE9e.js

@@ -0,0 +1,14 @@
+//#region session/core/hook-command-core.ts
+var SAFE_PATH_RE = /^[A-Za-z0-9_.:/\\ -]+$/;
+var SAFE_EVENT_RE = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
+function buildHookCommand(relayPath, event, argvTail = []) {
+	const rawPath = String(relayPath);
+	const rawEvent = String(event);
+	if (!SAFE_PATH_RE.test(rawPath)) return null;
+	if (!SAFE_EVENT_RE.test(rawEvent)) return null;
+	if (argvTail.some((argument) => !/^[A-Za-z0-9_-]+$/.test(argument))) return null;
+	const forwardSlashedPath = rawPath.replace(/\\/g, "/");
+	return `node ${/\s/.test(forwardSlashedPath) ? `"${forwardSlashedPath}"` : forwardSlashedPath} ${rawEvent}${argvTail.length ? ` ${argvTail.join(" ")}` : ""}`;
+}
+//#endregion
+export { buildHookCommand as t };

package/dist/chunks/hook-relay-core-BHfYFnYV.js

@@ -0,0 +1,88 @@
+//#region session/core/hook-relay-core.ts
+var HOOK_URL_ENV = "GLIMMERVOID_HOOK_URL";
+var MAX_RESPONSE_BYTES = 65536;
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
+	"127.0.0.1",
+	"::1",
+	"[::1]",
+	"localhost"
+]);
+var EVENT_RE = /^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/;
+var HOOK_PATH_PREFIX = "/hook/";
+function readHookUrl(env) {
+	const raw = env ? env[HOOK_URL_ENV] : null;
+	if (typeof raw !== "string") return null;
+	return raw.trim() || null;
+}
+function normalizeEvent(event) {
+	if (typeof event !== "string") return null;
+	const trimmed = event.trim();
+	if (!EVENT_RE.test(trimmed)) return null;
+	return trimmed.toLowerCase();
+}
+function resolveHookTarget(baseUrl, event, pathPrefix = HOOK_PATH_PREFIX) {
+	let target;
+	try {
+		target = new URL(baseUrl);
+	} catch {
+		return {
+			url: null,
+			reason: "bad-url"
+		};
+	}
+	if (target.protocol !== "http:") return {
+		url: null,
+		reason: "not-http"
+	};
+	if (!LOOPBACK_HOSTS.has(target.hostname)) return {
+		url: null,
+		reason: "not-loopback"
+	};
+	if (!target.pathname.startsWith(pathPrefix)) return {
+		url: null,
+		reason: "not-hook-path"
+	};
+	const base = target.pathname.replace(/\/+$/, "");
+	target.pathname = `${base}/${event}`;
+	return {
+		url: target.toString(),
+		reason: "ok"
+	};
+}
+function decideRelayPost({ env = {}, event = null, payloadBytes = 0 } = {}) {
+	const baseUrl = readHookUrl(env);
+	if (!baseUrl) return {
+		post: false,
+		url: null,
+		reason: "no-hook-url"
+	};
+	const name = normalizeEvent(event);
+	if (!name) return {
+		post: false,
+		url: null,
+		reason: "bad-event"
+	};
+	if (!Number.isFinite(payloadBytes) || payloadBytes < 0) return {
+		post: false,
+		url: null,
+		reason: "bad-payload"
+	};
+	if (payloadBytes > 65536) return {
+		post: false,
+		url: null,
+		reason: "payload-too-large"
+	};
+	const target = resolveHookTarget(baseUrl, name);
+	if (!target.url) return {
+		post: false,
+		url: null,
+		reason: target.reason
+	};
+	return {
+		post: true,
+		url: target.url,
+		reason: "ok"
+	};
+}
+//#endregion
+export { resolveHookTarget as i, MAX_RESPONSE_BYTES as n, decideRelayPost as r, HOOK_URL_ENV as t };

package/dist/chunks/hook-tools-pSJia7ks.js

@@ -0,0 +1,74 @@
+import { r as resolvePathCommandMatches } from "./spawn-command-Cc40FiZI.js";
+import { a as SANE_YOLO_PATH_ENV, n as RTK_PATH_ENV, o as saneYoloEnv } from "./rtk-hook-core-Bl6gYHPN.js";
+import { t as buildHookCommand } from "./hook-command-core-DclEoE9e.js";
+import path from "node:path";
+//#region session/core/hook-tools.ts
+function firstExistingFile(candidates, fsApi) {
+	for (const candidate of candidates) try {
+		if (fsApi.statSync(candidate).isFile()) return path.resolve(candidate);
+	} catch {}
+	return null;
+}
+function resolveRtkPath({ glimmervoidHome, platform, exec, fsApi }) {
+	const bundled = firstExistingFile([path.join(glimmervoidHome, "bin", "rtk.exe"), path.join(glimmervoidHome, "bin", "rtk")], fsApi);
+	if (bundled) return bundled;
+	const matches = resolvePathCommandMatches("rtk", {
+		platform,
+		exec
+	});
+	if (matches.length === 0) return null;
+	const firstMatch = matches[0];
+	if (!firstMatch) return null;
+	return path.resolve(firstMatch);
+}
+function quoteCommandPath(commandPath) {
+	if (!/\s/.test(commandPath)) return commandPath;
+	return `"${commandPath}"`;
+}
+function toForwardSlashes(commandPath) {
+	return commandPath.replace(/\\/g, "/");
+}
+function buildRtkHookEntry(rtkPath) {
+	return {
+		matcher: "Bash",
+		hooks: [{
+			type: "command",
+			command: `${quoteCommandPath(toForwardSlashes(rtkPath))} hook claude`
+		}]
+	};
+}
+function codexGroup(command) {
+	if (!command) return null;
+	return `{matcher='Bash',hooks=[{type='command',command='${command}'}]}`;
+}
+var HOOK_TOOLS = {
+	rtk: {
+		capability: "rtk",
+		purpose: "rtk command rewriting",
+		env: (tool) => ({ [RTK_PATH_ENV]: tool.binPath }),
+		claudeEntry: (tool) => buildRtkHookEntry(tool.binPath),
+		codexGroup: (_tool, relayPath) => codexGroup(buildHookCommand(relayPath, "rtk"))
+	},
+	saneYolo: {
+		capability: "saneYolo",
+		purpose: "Sane YOLO catastrophic command protection",
+		env: (tool, homeDir) => ({
+			[SANE_YOLO_PATH_ENV]: tool.binPath,
+			...saneYoloEnv(homeDir)
+		}),
+		claudeEntry: (tool) => ({
+			matcher: "Bash|PowerShell|Monitor",
+			hooks: [{
+				type: "command",
+				command: `node "${toForwardSlashes(tool.binPath)}" hook --coding-cli`
+			}]
+		}),
+		codexGroup: (tool) => codexGroup(buildHookCommand(tool.binPath, "hook", ["--codex"]))
+	}
+};
+function mergeCodexPreToolUse(groups) {
+	if (groups.length === 0) return [];
+	return ["-c", `hooks.PreToolUse=[${groups.join(",")}]`];
+}
+//#endregion
+export { mergeCodexPreToolUse as n, resolveRtkPath as r, HOOK_TOOLS as t };