@dyyz1993/pi-coding-agent 0.74.24 → 0.74.25

package/dist/extensions/claude-hooks-compat/config-loader.ts

@@ -0,0 +1,49 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { ClaudeHookConfig, MatcherGroup } from "./types.js";
+
+function loadSingleConfig(path: string): ClaudeHookConfig | null {
+	if (!existsSync(path)) return null;
+	try {
+		return JSON.parse(readFileSync(path, "utf-8"));
+	} catch (err) {
+		console.debug("[claude-hooks-compat] config load failed:", err instanceof Error ? err.message : err);
+		return null;
+	}
+}
+
+export function loadConfigs(projectDir: string): Map<string, MatcherGroup[]> {
+	const merged = new Map<string, MatcherGroup[]>();
+
+	const policyPath = process.env.CLAUDE_POLICY_FILE ?? "";
+	if (policyPath) {
+		const policy = loadSingleConfig(policyPath);
+		if (policy?.disableAllHooks) return merged;
+		if (policy?.hooks) {
+			for (const [eventName, groups] of Object.entries(policy.hooks)) {
+				merged.set(eventName, [...groups]);
+			}
+		}
+	}
+
+	const sources = [
+		{ path: join(homedir(), ".claude/settings.json"), name: "global" },
+		{ path: join(projectDir, ".claude/settings.json"), name: "project" },
+		{ path: join(projectDir, ".claude/settings.local.json"), name: "local" },
+	];
+
+	for (const source of sources) {
+		const config = loadSingleConfig(source.path);
+		if (!config) continue;
+		if (config.disableAllHooks) continue;
+		if (!config.hooks) continue;
+
+		for (const [eventName, groups] of Object.entries(config.hooks)) {
+			const existing = merged.get(eventName) ?? [];
+			merged.set(eventName, [...existing, ...groups]);
+		}
+	}
+
+	return merged;
+}

package/dist/extensions/claude-hooks-compat/handler-runner.ts

@@ -0,0 +1,377 @@
+import { spawn } from "node:child_process";
+import type { HookHandler, HookOutput, HookStdinData } from "./types.js";
+
+type CallLLMFn = (options: {
+	systemPrompt?: string;
+	messages: { role: "user" | "assistant"; content: string }[];
+	tools?: string[];
+	maxTurns?: number;
+	maxTokens?: number;
+	signal?: AbortSignal;
+}) => Promise<string>;
+
+export async function runHandler(
+	handler: HookHandler,
+	stdinData: HookStdinData,
+	ctx: { cwd: string; hasUI: boolean },
+	callLLM?: CallLLMFn,
+): Promise<HookOutput> {
+	switch (handler.type) {
+		case "command":
+			return runCommandHandler(handler, stdinData, ctx);
+		case "http":
+			return runHttpHandler(handler, stdinData);
+		case "prompt":
+			return runPromptHandler(handler, stdinData, callLLM);
+		case "agent":
+			return runAgentHandler(handler, stdinData, callLLM);
+		case "mcp_tool":
+			return { exitCode: 0, stdout: "", stderr: "" };
+		default:
+			return { exitCode: 0, stdout: "", stderr: "" };
+	}
+}
+
+export function replaceVariables(command: string, stdinData: HookStdinData, cwd: string): string {
+	return command
+		.replace(/\$CLAUDE_PROJECT_DIR/g, cwd)
+		.replace(/\$TOOL/g, stdinData.tool_name ?? "")
+		.replace(/\$BASH_COMMAND/g, ((stdinData.tool_input as Record<string, unknown>)?.command as string) ?? "")
+		.replace(/\$ARGUMENTS/g, JSON.stringify(stdinData.tool_input ?? {}));
+}
+
+export function replaceInputPlaceholders(
+	template: Record<string, unknown>,
+	stdinData: HookStdinData,
+): Record<string, unknown> {
+	const result: Record<string, unknown> = {};
+	for (const [key, value] of Object.entries(template)) {
+		if (typeof value === "string") {
+			result[key] = value.replace(/\$\{([^}]+)\}/g, (_, path) => {
+				return String(resolvePath(stdinData, path) ?? "");
+			});
+		} else if (value && typeof value === "object" && !Array.isArray(value)) {
+			result[key] = replaceInputPlaceholders(value as Record<string, unknown>, stdinData);
+		} else {
+			result[key] = value;
+		}
+	}
+	return result;
+}
+
+function resolvePath(obj: unknown, path: string): unknown {
+	const parts = path.split(".");
+	let current: unknown = obj;
+	for (const part of parts) {
+		if (current == null || typeof current !== "object") return undefined;
+		current = (current as Record<string, unknown>)[part];
+	}
+	return current;
+}
+
+export function replaceEnvVarsInHeaders(
+	headers: Record<string, string>,
+	allowedEnvVars: string[] | undefined,
+): Record<string, string> {
+	if (!allowedEnvVars || allowedEnvVars.length === 0) return headers;
+
+	const allowed = new Set(allowedEnvVars);
+	const result: Record<string, string> = {};
+
+	for (const [key, value] of Object.entries(headers)) {
+		result[key] = value.replace(/\$\{?(\w+)\}?/g, (match, varName) => {
+			if (allowed.has(varName)) {
+				return process.env[varName] ?? "";
+			}
+			return match;
+		});
+	}
+
+	return result;
+}
+
+function buildHookEnv(cwd: string, eventName: string): NodeJS.ProcessEnv {
+	const env = { ...process.env } as NodeJS.ProcessEnv;
+
+	if (process.env.GITHUB_ACTIONS === "true") {
+		for (const key of Object.keys(env)) {
+			if (key.startsWith("ANTHROPIC_") || key.startsWith("CLAUDE_CODE_OAUTH")) {
+				delete env[key];
+			}
+		}
+	}
+
+	env.CLAUDE_PROJECT_DIR = cwd;
+	env.CLAUDE_CODE_SHELL_PREFIX = "";
+
+	if (["SessionStart", "Setup", "CwdChanged", "FileChanged"].includes(eventName)) {
+		env.CLAUDE_ENV_FILE = `/tmp/claude-env-${Date.now()}`;
+	}
+
+	return env;
+}
+
+function runCommandHandler(handler: HookHandler, stdinData: HookStdinData, ctx: { cwd: string }): Promise<HookOutput> {
+	return new Promise((resolve) => {
+		const timeout = (handler.timeout ?? 600) * 1000;
+		const command = replaceVariables(handler.command ?? "", stdinData, ctx.cwd);
+		let stdout = "";
+		let stderr = "";
+		let settled = false;
+
+		const env = buildHookEnv(ctx.cwd, stdinData.hook_event_name);
+		const proc = spawn("bash", ["-c", command], {
+			cwd: ctx.cwd,
+			env,
+		});
+
+		const timer = setTimeout(() => {
+			if (settled) return;
+			settled = true;
+			proc.kill("SIGTERM");
+			resolve({ exitCode: 1, stdout: "", stderr: "Hook timed out" });
+		}, timeout);
+
+		proc.stdin.write(JSON.stringify(stdinData));
+		proc.stdin.end();
+
+		proc.stdout.on("data", (d: Buffer) => {
+			stdout += d.toString();
+		});
+		proc.stderr.on("data", (d: Buffer) => {
+			stderr += d.toString();
+		});
+
+		proc.on("close", (code) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+
+			const result: HookOutput = {
+				exitCode: code ?? 0,
+				stdout: stdout.trim(),
+				stderr: stderr.trim(),
+			};
+
+			if (result.exitCode === 0 && stdout.trim().startsWith("{")) {
+				try {
+					result.parsed = JSON.parse(stdout.trim());
+				} catch (err) {
+					console.debug("[claude-hooks-compat] stdout JSON parse failed:", err instanceof Error ? err.message : err);
+				}
+			}
+
+			resolve(result);
+		});
+
+		proc.on("error", (err) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			resolve({ exitCode: 1, stdout: "", stderr: err.message });
+		});
+	});
+}
+
+async function runHttpHandler(handler: HookHandler, stdinData: HookStdinData): Promise<HookOutput> {
+	const timeout = (handler.timeout ?? 600) * 1000;
+
+	try {
+		const urlStr = handler.url ?? "";
+		let parsedUrl: URL;
+		try {
+			parsedUrl = new URL(urlStr);
+		} catch (err) {
+			console.debug("[claude-hooks-compat] URL parse failed:", err instanceof Error ? err.message : err);
+			return { exitCode: 1, stdout: "", stderr: `Invalid URL: ${urlStr}` };
+		}
+
+		if (parsedUrl.protocol !== "https:") {
+			return { exitCode: 1, stdout: "", stderr: "Only HTTPS URLs are allowed" };
+		}
+
+		const hostname = parsedUrl.hostname.toLowerCase();
+		if (isPrivateIP(hostname)) {
+			return { exitCode: 1, stdout: "", stderr: `Requests to private addresses are not allowed: ${hostname}` };
+		}
+
+		const rawHeaders = handler.headers ?? {};
+		const headers = replaceEnvVarsInHeaders(rawHeaders, handler.allowedEnvVars);
+		headers["Content-Type"] = headers["Content-Type"] ?? "application/json";
+
+		const resp = await fetch(urlStr, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(stdinData),
+			signal: AbortSignal.timeout(timeout),
+		});
+
+		if (resp.ok) {
+			const text = await resp.text();
+			let parsed: HookOutput["parsed"];
+			try {
+				parsed = JSON.parse(text);
+			} catch (err) {
+				console.debug("[claude-hooks-compat] HTTP response JSON parse failed:", err instanceof Error ? err.message : err);
+			}
+			return { exitCode: 0, stdout: text, stderr: "", parsed };
+		}
+
+		if (resp.status === 403) {
+			const body = await resp.text().catch((err) => {
+				console.debug("[claude-hooks-compat] 403 body read failed:", err instanceof Error ? err.message : err);
+				return "";
+			});
+			return { exitCode: 2, stdout: "", stderr: body || `HTTP ${resp.status}` };
+		}
+
+		return { exitCode: 1, stdout: "", stderr: `HTTP ${resp.status}` };
+	} catch (err) {
+		return { exitCode: 1, stdout: "", stderr: (err as Error).message };
+	}
+}
+
+function isPrivateIP(hostname: string): boolean {
+	if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "0.0.0.0") {
+		return true;
+	}
+
+	if (hostname === "::1" || hostname === "[::1]") {
+		return true;
+	}
+
+	const ipv4Match = hostname.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+	if (ipv4Match) {
+		const [, a, b] = ipv4Match.map(Number);
+		if (a === 10) return true;
+		if (a === 172 && b >= 16 && b <= 31) return true;
+		if (a === 192 && b === 168) return true;
+		if (a === 169 && b === 254) return true;
+		if (a === 127) return true;
+		if (a === 0) return true;
+	}
+
+	if (hostname.startsWith("fc") || hostname.startsWith("fd") || hostname.startsWith("fe80")) {
+		return true;
+	}
+
+	return false;
+}
+
+async function runPromptHandler(
+	handler: HookHandler,
+	stdinData: HookStdinData,
+	callLLM?: CallLLMFn,
+): Promise<HookOutput> {
+	if (!callLLM || !handler.prompt) {
+		return { exitCode: 0, stdout: "", stderr: "" };
+	}
+
+	const timeout = (handler.timeout ?? 30) * 1000;
+
+	try {
+		const promptText = handler.prompt.replace(/\$ARGUMENTS/g, JSON.stringify(stdinData));
+
+		const response = await callLLM({
+			systemPrompt:
+				"You are a hook evaluator. Respond with a JSON object. If the action should proceed, respond with {\"ok\":true}. If it should be blocked, respond with {\"ok\":false,\"reason\":\"...\"}.",
+			messages: [{ role: "user", content: promptText }],
+			maxTokens: 1024,
+			signal: AbortSignal.timeout(timeout),
+		});
+
+		let parsed: HookOutput["parsed"];
+		try {
+			parsed = JSON.parse(response);
+		} catch (err) {
+			console.debug("[claude-hooks-compat] prompt handler JSON parse failed:", err instanceof Error ? err.message : err);
+		}
+
+		return { exitCode: 0, stdout: response, stderr: "", parsed };
+	} catch (err) {
+		return { exitCode: 1, stdout: "", stderr: (err as Error).message };
+	}
+}
+
+async function runAgentHandler(
+	handler: HookHandler,
+	stdinData: HookStdinData,
+	callLLM?: CallLLMFn,
+): Promise<HookOutput> {
+	if (!callLLM || !handler.prompt) {
+		return { exitCode: 0, stdout: "", stderr: "" };
+	}
+
+	const timeout = (handler.timeout ?? 60) * 1000;
+
+	try {
+		const promptText = handler.prompt.replace(/\$ARGUMENTS/g, JSON.stringify(stdinData));
+
+		const response = await callLLM({
+			systemPrompt:
+				"You are a hook evaluator agent. You can use tools to verify conditions. Respond with a JSON object. If the action should proceed, respond with {\"ok\":true}. If it should be blocked, respond with {\"ok\":false,\"reason\":\"...\"}.",
+			messages: [{ role: "user", content: promptText }],
+			maxTurns: 50,
+			maxTokens: 4096,
+			signal: AbortSignal.timeout(timeout),
+		});
+
+		let parsed: HookOutput["parsed"];
+		try {
+			parsed = JSON.parse(response);
+		} catch (err) {
+			console.debug("[claude-hooks-compat] agent handler JSON parse failed:", err instanceof Error ? err.message : err);
+		}
+
+		return { exitCode: 0, stdout: response, stderr: "", parsed };
+	} catch (err) {
+		return { exitCode: 1, stdout: "", stderr: (err as Error).message };
+	}
+}
+
+export function interpretHookOutput(output: HookOutput): {
+	shouldBlock: boolean;
+	reason: string;
+	updatedInput?: Record<string, unknown>;
+	additionalContext?: string;
+	systemMessage?: string;
+	suppressOutput?: boolean;
+	retry?: boolean;
+} {
+	if (output.exitCode === 2) {
+		return { shouldBlock: true, reason: output.stderr || "Blocked by hook" };
+	}
+
+	if (output.parsed) {
+		const p = output.parsed;
+
+		if (p.continue === false) {
+			return { shouldBlock: true, reason: p.stopReason || "Hook stopped execution" };
+		}
+
+		if (p.ok === false) {
+			return { shouldBlock: true, reason: p.reason || "Blocked by hook" };
+		}
+
+		if (p.decision === "block") {
+			return { shouldBlock: true, reason: p.reason || "Blocked by hook" };
+		}
+
+		const hso = p.hookSpecificOutput;
+		if (hso?.permissionDecision === "deny") {
+			return { shouldBlock: true, reason: hso.permissionDecisionReason || "Denied by hook" };
+		}
+
+		return {
+			shouldBlock: false,
+			reason: "",
+			updatedInput: hso?.updatedInput ?? hso?.modifiedToolInput,
+			additionalContext: hso?.additionalContext,
+			systemMessage: p.systemMessage,
+			suppressOutput: p.suppressOutput,
+			retry: hso?.retry === true,
+		};
+	}
+
+	return { shouldBlock: false, reason: "" };
+}

package/dist/extensions/claude-hooks-compat/if-parser.ts

@@ -0,0 +1,53 @@
+import type { IfClause } from "./types.js";
+
+export function parseIfClause(ifClause: string): IfClause | null {
+	const match = ifClause.match(/^(\w+)\((.+)\)$/);
+	if (!match) return null;
+	return { tool: match[1], pattern: match[2] };
+}
+
+export function matchesIfClause(
+	ifClause: string | undefined,
+	toolName: string,
+	toolInput: Record<string, unknown>,
+): boolean {
+	if (!ifClause) return true;
+
+	const parsed = parseIfClause(ifClause);
+	if (!parsed) return true;
+	if (parsed.tool !== toolName) return false;
+
+	if (toolName === "Bash") {
+		const command = (toolInput.command as string) ?? "";
+		return globMatch(parsed.pattern, command);
+	}
+
+	if (toolName === "Edit" || toolName === "Write") {
+		const filePath = (toolInput.file_path as string) ?? (toolInput.path as string) ?? "";
+		return globMatch(parsed.pattern, filePath);
+	}
+
+	if (toolName === "Read") {
+		const filePath = (toolInput.file_path as string) ?? (toolInput.path as string) ?? "";
+		return globMatch(parsed.pattern, filePath);
+	}
+
+	return true;
+}
+
+function globMatch(pattern: string, text: string): boolean {
+	const regex = globToRegex(pattern);
+	try {
+		return new RegExp(regex).test(text);
+	} catch (err) {
+		console.debug("[claude-hooks-compat] glob regex match failed:", err instanceof Error ? err.message : err);
+		return false;
+	}
+}
+
+function globToRegex(pattern: string): string {
+	return pattern
+		.replace(/[.+^${}()|[\]\\]/g, "\\$&")
+		.replace(/\*/g, ".*")
+		.replace(/\?/g, ".");
+}

package/dist/extensions/claude-hooks-compat/index.ts

@@ -0,0 +1,178 @@
+import type { ExtensionAPI, ToolResultEvent, BeforeAgentStartEvent } from "@dyyz1993/pi-coding-agent";
+import type { MatcherGroup, HookHandler } from "./types.js";
+import { loadConfigs } from "./config-loader.js";
+import { matchesMatcher } from "./matcher.js";
+import { matchesIfClause } from "./if-parser.js";
+import { buildStdinData } from "./stdin-builder.js";
+import { runHandler, interpretHookOutput } from "./handler-runner.js";
+
+function matchesPiVariables(
+	handler: HookHandler,
+	ctxVars: Record<string, unknown> | undefined,
+): boolean {
+	const piVars = handler["x-pi-variables"];
+	if (!piVars || !ctxVars) return true;
+
+	for (const [key, value] of Object.entries(piVars)) {
+		const ctxValue = String(ctxVars[key] ?? "");
+		const allowedValues = value.split("|");
+		if (!allowedValues.includes(ctxValue)) return false;
+	}
+
+	return true;
+}
+
+export default function (pi: ExtensionAPI) {
+	let configs: Map<string, MatcherGroup[]> = new Map();
+	const onceHandlers = new Set<number>();
+
+	pi.on("session_start", async (_event, ctx) => {
+		configs = loadConfigs(ctx.cwd);
+	});
+
+	pi.on("tool_call", async (event, ctx) => {
+		const result = await processHookEvent("PreToolUse", event, ctx);
+		return result;
+	});
+
+	pi.on("tool_result", async (event: ToolResultEvent, ctx) => {
+		const toolOutput = event.content.map((c) => c.type === "text" ? c.text : "").join("");
+		const hookName = event.isError ? "PostToolUseFailure" : "PostToolUse";
+		await processHookEvent(hookName, {
+			toolName: event.toolName,
+			input: event.input ?? {},
+			toolCallId: event.toolCallId,
+			toolOutput,
+		}, ctx);
+		return undefined;
+	});
+
+	pi.on("before_agent_start", async (event: BeforeAgentStartEvent, ctx) => {
+		const result = await processHookEvent("UserPromptSubmit", {
+			toolName: "",
+			input: { prompt: event.prompt ?? "" },
+		}, ctx);
+		if (result?.block) {
+			return { message: { customType: "hook_block", content: result.reason, display: true } };
+		}
+		return undefined;
+	});
+
+	pi.on("session_shutdown", async (_event, ctx) => {
+		await processHookEvent("SessionEnd", { toolName: "", input: {} }, ctx);
+	});
+
+	pi.on("session_compact", async (_event, ctx) => {
+		await processHookEvent("PreCompact", { toolName: "", input: {} }, ctx);
+	});
+
+	pi.on("message_start", async (event, ctx) => {
+		const messageText = typeof event.message === "object" && event.message !== null && "content" in event.message
+			? String((event.message as { content: unknown }).content ?? "")
+			: "";
+		await processHookEvent("Notification", {
+			toolName: "",
+			input: { message: messageText },
+		}, ctx);
+	});
+
+	pi.on("agent_start", async (_event, ctx) => {
+		await processHookEvent("SubagentStart", { toolName: "", input: {} }, ctx);
+	});
+
+	pi.on("agent_end", async (_event, ctx) => {
+		await processHookEvent("SubagentStop", { toolName: "", input: {} }, ctx);
+	});
+
+	pi.on("turn_end", async (_event, ctx) => {
+		await processHookEvent("Stop", { toolName: "", input: {} }, ctx);
+	});
+
+	async function processHookEvent(
+		hookEventName: string,
+		event: { toolName: string; input: Record<string, unknown>; toolCallId?: string; toolOutput?: string },
+		ctx: { cwd: string; hasUI: boolean },
+	): Promise<{ block: boolean; reason: string } | undefined> {
+		const groups = configs.get(hookEventName) ?? [];
+		if (groups.length === 0) return undefined;
+
+		const ctxVars = ((ctx as unknown) as Record<string, unknown>).variables as Record<string, unknown> | undefined;
+		const agentType = (ctxVars?.role ?? ctxVars?.agent_type) as string | undefined;
+		const stdinData = buildStdinData(hookEventName, {
+			toolName: event.toolName,
+			toolInput: event.input,
+			toolOutput: event.toolOutput,
+			toolUseId: event.toolCallId,
+			cwd: ctx.cwd,
+			agentType,
+		});
+
+		for (const group of groups) {
+			if (!matchesMatcher(group.matcher, event.toolName)) continue;
+
+			for (let i = 0; i < group.hooks.length; i++) {
+				const handler = group.hooks[i];
+
+				if (handler.once && onceHandlers.has(handlerIndex(hookEventName, i))) continue;
+				if (!matchesIfClause(handler.if, event.toolName, event.input)) continue;
+				if (!matchesPiVariables(handler, ctxVars)) continue;
+
+				if (handler.once) onceHandlers.add(handlerIndex(hookEventName, i));
+
+				const isAsync = handler.async ?? handler.asyncRewake ?? false;
+				if (isAsync && hookEventName === "PreToolUse") {
+					const runner = getCallLLM(pi);
+					runHandler(handler, stdinData, ctx, runner).then((output) => {
+						const result = interpretHookOutput(output);
+						if (handler.asyncRewake && output.exitCode === 2 && result.reason) {
+							pi.sendMessage({
+								customType: "hook_async_block",
+								content: result.reason,
+								display: true,
+							});
+						}
+					});
+					continue;
+				}
+
+				const output = await runHandler(handler, stdinData, ctx, getCallLLM(pi));
+				const result = interpretHookOutput(output);
+
+				if (result.shouldBlock) {
+					return { block: true, reason: result.reason };
+				}
+
+				if (result.updatedInput) {
+					Object.assign(event.input, result.updatedInput);
+				}
+			}
+		}
+
+		return undefined;
+	}
+}
+
+function handlerIndex(event: string, idx: number): number {
+	return (hashString(event) * 31 + idx) | 0;
+}
+
+function hashString(s: string): number {
+	let h = 0;
+	for (let i = 0; i < s.length; i++) {
+		h = (h * 31 + s.charCodeAt(i)) | 0;
+	}
+	return h;
+}
+
+function getCallLLM(pi: ExtensionAPI) {
+	return ((pi as unknown) as Record<string, unknown>).callLLM as
+		| ((options: {
+				systemPrompt?: string;
+				messages: { role: "user" | "assistant"; content: string }[];
+				tools?: string[];
+				maxTurns?: number;
+				maxTokens?: number;
+				signal?: AbortSignal;
+		  }) => Promise<string>)
+		| undefined;
+}

package/dist/extensions/claude-hooks-compat/matcher.ts

@@ -0,0 +1,17 @@
+export function matchesMatcher(matcher: string | undefined, toolName: string): boolean {
+	if (!matcher || matcher === "" || matcher === "*") return true;
+
+	if (/^[a-zA-Z0-9_|]+$/.test(matcher)) {
+		return matcher
+			.split("|")
+			.map((s) => s.trim().toLowerCase())
+			.includes(toolName.toLowerCase());
+	}
+
+	try {
+		return new RegExp(matcher).test(toolName);
+	} catch (err) {
+		console.debug("[claude-hooks-compat] matcher regex failed:", err instanceof Error ? err.message : err);
+		return false;
+	}
+}

package/dist/extensions/claude-hooks-compat/stdin-builder.ts

@@ -0,0 +1,27 @@
+import type { HookStdinData } from "./types.js";
+
+export function buildStdinData(
+	eventName: string,
+	extra: {
+		toolName?: string;
+		toolInput?: Record<string, unknown>;
+		toolOutput?: string;
+		toolUseId?: string;
+		cwd: string;
+		sessionId?: string;
+		agentType?: string;
+	},
+): HookStdinData {
+	return {
+		session_id: extra.sessionId ?? "",
+		transcript_path: "",
+		cwd: extra.cwd,
+		permission_mode: "default",
+		hook_event_name: eventName,
+		tool_name: extra.toolName,
+		tool_input: extra.toolInput,
+		tool_use_id: extra.toolUseId,
+		tool_output: extra.toolOutput,
+		agent_type: extra.agentType,
+	};
+}