@agimon-ai/po-hook 0.0.0-alpha.0

package/dist/extensions/server.mjs

@@ -0,0 +1,606 @@
+import { a as createBashHookRunner, b as isDenied, c as createHookDocumentReader, d as selectRegistryHooks, g as decisionReason, h as additionalContextsFrom, i as createHookTelemetry, n as HOOK_EVENT, o as sessionHookPayload, r as selectPluginHooks, s as toolHookPayload, t as createHookModules, x as toolResultMessages, y as hookFailureMessage } from "../hookModules-GoRDG8mg.mjs";
+import { composeServerProviderOverrides, defineServerPlugin, packageResourcePath, readPackageResource } from "@agimon-ai/po-core/serverFacet";
+import { composeRootHooks, defineHook, defineResource, defineRoot } from "@agimon-ai/po-core/extensionFile";
+import { DoomHeadlessPromptAdmissionError } from "@agimon-ai/po-core/headless";
+import { requireDoomConfigContext } from "@agimon-ai/po-config/piContext";
+import { DOOM_CHILD_SESSION_HOOKS_SERVICE } from "@agimon-ai/po-core/childSession";
+import { DOOM_CONFIG_SERVICE } from "@agimon-ai/po-core/config";
+import { DOOM_HELP_WHEN } from "@agimon-ai/po-core/help";
+//#region src/constants/hookHandlers.ts
+const STATUS_PREFIX = "repository-hooks";
+const FAILURE_MESSAGE_TYPE = "repository-hook-failure";
+/** Claude's Stop hook input field: true when the agent is already continuing because of a Stop hook. */
+const STOP_HOOK_ACTIVE_FIELD = "stop_hook_active";
+const SUBAGENT_ENVIRONMENT_FLAG = "PI_SUBAGENT_CHILD";
+//#endregion
+//#region src/services/hookDispatch/index.ts
+function isJson(value, ancestors = /* @__PURE__ */ new Set()) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (typeof value !== "object" || ancestors.has(value)) return false;
+	ancestors.add(value);
+	const valid = (Array.isArray(value) || Object.getPrototypeOf(value) === Object.prototype) && Object.values(value).every((entry) => isJson(entry, ancestors));
+	ancestors.delete(value);
+	return valid;
+}
+function commandFailure(row, error) {
+	return {
+		command: row.hook.command ?? row.hook.module,
+		message: error instanceof Error ? error.message : String(error),
+		reason: "hook_execution"
+	};
+}
+/** Registry rows interleave command and module bindings, followed by plugin commands. */
+async function dispatchHooks(session, scope, request) {
+	const signal = scope.operationSignal ? AbortSignal.any([scope.signal, scope.operationSignal]) : scope.signal;
+	signal.throwIfAborted();
+	const harness = session.config().harness;
+	const plugins = await session.documents.plugins(harness.pluginHooks);
+	const registry = request.eventName === HOOK_EVENT.sessionEnd ? {
+		entries: [],
+		failure: void 0
+	} : await session.documents.registry(scope.repoRoot);
+	signal.throwIfAborted();
+	const event = request.event;
+	const toolName = event && "toolName" in event ? event.toolName : void 0;
+	const hooks = [...selectRegistryHooks(registry.entries, {
+		event: request.eventName,
+		toolName,
+		allowedGroups: harness.hookGroups,
+		inSubagent: scope.isSubagent
+	}), ...selectPluginHooks(plugins.documents, request.eventName, toolName)];
+	const decisions = [];
+	const failures = [...registry.failure ? [registry.failure] : [], ...plugins.failures];
+	let toolCall;
+	let patchedResult = false;
+	for (const [index, row] of hooks.entries()) {
+		signal.throwIfAborted();
+		request.progress?.(index, hooks.length);
+		if (row.hook.command === void 0) {
+			if (!event) continue;
+			let proposed;
+			try {
+				proposed = structuredClone(event);
+			} catch (error) {
+				failures.push(commandFailure(row, error));
+				continue;
+			}
+			const outcome = await session.modules.invoke(row, proposed, scope, scope.operationSignal);
+			signal.throwIfAborted();
+			if (outcome.failure) {
+				failures.push(outcome.failure);
+				continue;
+			}
+			try {
+				if (event.type === "tool_call" && proposed.type === "tool_call") {
+					if (typeof proposed.input !== "object" || proposed.input === null || Array.isArray(proposed.input) || !isJson(proposed.input)) throw new Error("Hook tool input must be a JSON object.");
+					const input = structuredClone(proposed.input);
+					for (const key of Object.keys(event.input)) delete event.input[key];
+					Object.assign(event.input, input);
+					if (outcome.result && "block" in outcome.result && outcome.result.block) {
+						toolCall = {
+							block: true,
+							reason: outcome.result.reason ?? "Blocked by repository hook"
+						};
+						break;
+					}
+				} else if (event.type === "tool_result" && outcome.result) {
+					const patch = structuredClone(outcome.result);
+					if ("content" in patch && patch.content !== void 0) event.content = patch.content;
+					if ("details" in patch) event.details = patch.details;
+					if ("isError" in patch && patch.isError !== void 0) event.isError = patch.isError;
+					patchedResult = true;
+				}
+			} catch (error) {
+				failures.push(commandFailure(row, error));
+			}
+			continue;
+		}
+		const payload = event && "toolName" in event ? toolHookPayload(event, request.eventName, scope.repoRoot, scope.sessionId, {
+			parentSessionId: scope.parentSessionId,
+			agent: scope.agent
+		}) : sessionHookPayload(scope.sessionId, scope.repoRoot);
+		let outcome;
+		try {
+			outcome = await session.runner.run(row.hook, {
+				...payload,
+				...request.extraPayload
+			}, {
+				repoRoot: scope.repoRoot,
+				pluginRoot: row.root
+			});
+		} catch (error) {
+			failures.push(commandFailure(row, error));
+			continue;
+		}
+		signal.throwIfAborted();
+		if (outcome.failure) failures.push(outcome.failure);
+		if (!outcome.decision) continue;
+		decisions.push(outcome.decision);
+		if (event?.type === "tool_result") {
+			const messages = toolResultMessages([outcome.decision]);
+			if (messages.length > 0) event.content = [...event.content, {
+				type: "text",
+				text: messages.join("\n\n")
+			}];
+			if (isDenied(outcome.decision)) event.isError = true;
+			patchedResult ||= messages.length > 0 || isDenied(outcome.decision);
+		}
+		if (isDenied(outcome.decision)) {
+			if (event?.type === "tool_call") toolCall = {
+				block: true,
+				reason: decisionReason(outcome.decision) ?? "Blocked by repository hook"
+			};
+			break;
+		}
+	}
+	if (event?.type === "tool_call" && !toolCall) {
+		const context = additionalContextsFrom(decisions).join("\n\n");
+		if (context) toolCall = {
+			block: true,
+			reason: context
+		};
+	}
+	if (event?.type === "tool_result" && failures.length > 0) {
+		event.content = [...event.content, {
+			type: "text",
+			text: hookFailureMessage(failures)
+		}];
+		patchedResult = true;
+	}
+	return {
+		decisions,
+		failures,
+		...toolCall ? { toolCall } : {},
+		...event?.type === "tool_result" && patchedResult ? { toolResult: {
+			content: event.content,
+			details: event.details,
+			isError: event.isError
+		} } : {}
+	};
+}
+//#endregion
+//#region src/services/hookRuntime/type.ts
+const DOOM_HOOK_SESSION_SERVICE = "doom/hook-session";
+//#endregion
+//#region src/services/hookRuntime/index.ts
+function createHookSession(config, options, signal) {
+	let telemetry = options.telemetry;
+	const requireTelemetry = () => telemetry ??= createHookTelemetry();
+	const modules = createHookModules({ descriptor: config().harness.hookModules });
+	const documents = options.documents ?? createHookDocumentReader({ telemetry: requireTelemetry() });
+	let preparation;
+	return {
+		config,
+		signal,
+		modules,
+		prepare(isSubagent = false) {
+			preparation ??= (async () => {
+				const harness = config().harness;
+				if (harness.hooks === false) return;
+				const registry = await documents.registry(harness.root ?? process.cwd());
+				if (registry.failure) return;
+				const allowed = harness.hookGroups === void 0 ? void 0 : new Set(harness.hookGroups);
+				const rows = registry.entries.filter((row) => row.core || !allowed || allowed.has(row.groupId)).filter((row) => !(isSubagent && row.skipInSubagent));
+				await modules.validate(rows);
+			})();
+			return preparation;
+		},
+		runner: options.runner ?? createBashHookRunner({ telemetry: requireTelemetry() }),
+		documents
+	};
+}
+function childHooksFor(parent) {
+	return { bind(scope) {
+		const config = structuredClone(parent.config());
+		const controller = new AbortController();
+		const signal = AbortSignal.any([controller.signal, scope.signal]);
+		const session = createHookSession(() => config, {
+			runner: parent.runner,
+			documents: parent.documents
+		}, signal);
+		let disposal;
+		const context = () => {
+			const sessionId = scope.sessionId();
+			if (!sessionId) throw new Error("Child hook identity is unavailable before runtime startup.");
+			return {
+				sessionId,
+				parentSessionId: scope.request.parentSessionId,
+				agent: scope.request.agent,
+				isSubagent: true,
+				cwd: scope.request.cwd,
+				repoRoot: config.harness.root ?? scope.request.cwd,
+				signal,
+				sendMessage: (text, delivery) => scope.sendMessage(text, delivery),
+				appendCustomEntry: (type, data) => scope.appendCustomEntry(type, data)
+			};
+		};
+		return {
+			async beforeTool(event, execution) {
+				await session.prepare(true);
+				const native = {
+					type: "tool_call",
+					toolCallId: event.toolCallId,
+					toolName: event.toolName,
+					input: event.args
+				};
+				const result = await dispatchHooks(session, {
+					...context(),
+					operationSignal: execution.abortSignal
+				}, {
+					eventName: HOOK_EVENT.preToolUse,
+					event: native
+				});
+				if (result.failures.length > 0) await scope.sendMessage(hookFailureMessage(result.failures), "steer");
+				return result.toolCall?.block ? { block: { reason: result.toolCall.reason ?? "Blocked by repository hook" } } : { args: native.input };
+			},
+			async afterTool(event, execution) {
+				const native = {
+					type: "tool_result",
+					toolCallId: event.toolCallId,
+					toolName: event.toolName,
+					input: event.args,
+					content: event.content,
+					details: event.details,
+					isError: event.isError
+				};
+				const result = await dispatchHooks(session, {
+					...context(),
+					operationSignal: execution.abortSignal
+				}, {
+					eventName: HOOK_EVENT.postToolUse,
+					event: native
+				});
+				return result.toolResult ? {
+					content: result.toolResult.content,
+					details: result.toolResult.details,
+					isError: result.toolResult.isError
+				} : void 0;
+			},
+			dispose() {
+				disposal ??= (async () => {
+					controller.abort();
+					await session.modules.dispose();
+				})();
+				return disposal;
+			}
+		};
+	} };
+}
+function createHookRuntime(cordis, options, parentContext, lifetimeSignal) {
+	const controller = new AbortController();
+	const signal = lifetimeSignal ? AbortSignal.any([controller.signal, lifetimeSignal]) : controller.signal;
+	const session = {
+		...createHookSession(() => requireDoomConfigContext(cordis), options, signal),
+		parentContext
+	};
+	let disposal;
+	let active = true;
+	return {
+		session,
+		childHooks: childHooksFor(session),
+		isCurrent: () => active && !signal.aborted,
+		dispose() {
+			active = false;
+			controller.abort();
+			disposal ??= session.modules.dispose();
+			return disposal;
+		}
+	};
+}
+function createHookBinding(options, parentContext, lifetimeSignal) {
+	let runtime;
+	return {
+		plugin(cordis) {
+			cordis.inject([DOOM_CONFIG_SERVICE], (configContext) => {
+				const binding = createHookRuntime(configContext, options, parentContext, lifetimeSignal);
+				runtime = binding;
+				configContext.provide(DOOM_CHILD_SESSION_HOOKS_SERVICE, binding.childHooks);
+				configContext.provide(DOOM_HOOK_SESSION_SERVICE, binding);
+				return async () => {
+					if (runtime === binding) runtime = void 0;
+					await binding.dispose();
+				};
+			});
+		},
+		runtime: () => runtime
+	};
+}
+//#endregion
+//#region src/services/serverHooks/index.ts
+function hookEntry(event) {
+	return {
+		version: 1,
+		event: typeof event.type === "string" ? event.type : "headless-hook",
+		data: event
+	};
+}
+function scopeFor(runtime, execution) {
+	return {
+		sessionId: execution.sessionId,
+		isSubagent: Boolean(execution.environment[SUBAGENT_ENVIRONMENT_FLAG]),
+		cwd: execution.cwd,
+		repoRoot: execution.repoRoot,
+		model: execution.model,
+		signal: runtime.session.signal,
+		operationSignal: execution.signal,
+		async sendMessage(text, delivery) {
+			if (!execution.session.admitPrompt) throw new DoomHeadlessPromptAdmissionError("The session cannot admit a hook prompt.");
+			await execution.session.admitPrompt(text, delivery);
+		},
+		appendCustomEntry: (type, data) => execution.session.appendCustomEntry(type, data)
+	};
+}
+/** One native owner dispatches lifecycle and tool rows for this session. */
+function createServerHooks(resolveRuntime) {
+	const startups = /* @__PURE__ */ new WeakMap();
+	const shutdowns = /* @__PURE__ */ new WeakMap();
+	const refusals = /* @__PURE__ */ new WeakMap();
+	async function runLifecycle(runtime, execution, eventName, event, extraPayload) {
+		const key = `${STATUS_PREFIX}:${execution.sessionId}:${eventName}`;
+		try {
+			return await dispatchHooks(runtime.session, scopeFor(runtime, execution), {
+				eventName,
+				event,
+				extraPayload,
+				progress: (index, total) => execution.client.setStatus(key, `Running ${eventName} hooks (${index + 1}/${total})...`)
+			});
+		} finally {
+			execution.client.setStatus(key, void 0);
+		}
+	}
+	function start(runtime, execution, event = { type: "session_start" }) {
+		let startup = startups.get(runtime);
+		if (!startup) {
+			startup = (async () => {
+				const scope = scopeFor(runtime, execution);
+				await runtime.session.prepare(scope.isSubagent);
+				if (scope.isSubagent) return;
+				const result = await runLifecycle(runtime, execution, HOOK_EVENT.sessionStart, {
+					...event,
+					type: "session_start"
+				});
+				if (!runtime.isCurrent()) return;
+				if (result.failures.length) await scope.sendMessage(hookFailureMessage(result.failures), "steer");
+				const context = additionalContextsFrom(result.decisions).join("\n\n");
+				if (context) await scope.sendMessage(context, "steer");
+			})();
+			startups.set(runtime, startup);
+		}
+		return startup;
+	}
+	return {
+		sessionStart: {
+			event: "session_start",
+			async handle(event, execution) {
+				const runtime = resolveRuntime();
+				if (runtime?.isCurrent()) await start(runtime, execution, event);
+			}
+		},
+		agentEnd: {
+			event: "agent_end",
+			async handle(event, execution) {
+				const runtime = resolveRuntime();
+				if (!runtime?.isCurrent() || scopeFor(runtime, execution).isSubagent) return;
+				await start(runtime, execution);
+				const count = refusals.get(runtime) ?? 0;
+				const result = await runLifecycle(runtime, execution, HOOK_EVENT.stop, {
+					...event,
+					type: "agent_settled"
+				}, { [STOP_HOOK_ACTIVE_FIELD]: count > 0 });
+				if (!runtime.isCurrent()) return;
+				const appendFailure = async (text) => {
+					if (!execution.session.appendMessage) throw new Error("The session cannot append hook diagnostics.");
+					await execution.session.appendMessage({
+						type: FAILURE_MESSAGE_TYPE,
+						text
+					});
+				};
+				if (result.failures.length) await appendFailure(hookFailureMessage(result.failures));
+				const reason = decisionReason(result.decisions.find(isDenied));
+				if (!reason) {
+					refusals.set(runtime, 0);
+					return;
+				}
+				if (count >= 5) {
+					refusals.set(runtime, 0);
+					await appendFailure(`A Stop hook refused ${String(5)} stops in a row, so the agent stops here. Its last reason: ${reason}`);
+					return;
+				}
+				await scopeFor(runtime, execution).sendMessage(reason, "followUp");
+				refusals.set(runtime, count + 1);
+			}
+		},
+		beforeAgentStart: {
+			event: "before_agent_start",
+			async handle(event, execution) {
+				const runtime = resolveRuntime();
+				if (runtime?.isCurrent()) await start(runtime, execution);
+				await execution.session.appendCustomEntry("doom-hook", hookEntry(event));
+			}
+		},
+		toolCall: {
+			event: "tool_call",
+			async handle(event, execution) {
+				const runtime = resolveRuntime();
+				if (!runtime?.isCurrent()) return;
+				const scope = scopeFor(runtime, execution);
+				try {
+					await start(runtime, execution);
+				} catch (error) {
+					return { block: { reason: error instanceof Error ? error.message : String(error) } };
+				}
+				const native = {
+					type: "tool_call",
+					toolCallId: event.toolCallId,
+					toolName: event.toolName,
+					input: event.args
+				};
+				const key = `${STATUS_PREFIX}:${native.toolCallId}:pre`;
+				try {
+					const result = await dispatchHooks(runtime.session, scope, {
+						eventName: HOOK_EVENT.preToolUse,
+						event: native,
+						progress: (index, total) => execution.client.setStatus(key, `Running pre-tool hooks for ${native.toolName} (${index + 1}/${total})...`)
+					});
+					if (result.failures.length > 0) await scope.sendMessage(hookFailureMessage(result.failures), "steer");
+					return result.toolCall?.block ? { block: { reason: result.toolCall.reason ?? "Blocked by repository hook" } } : { args: native.input };
+				} finally {
+					execution.client.setStatus(key, void 0);
+				}
+			}
+		},
+		toolResult: {
+			event: "tool_result",
+			async handle(event, execution) {
+				await execution.session.appendCustomEntry("doom-hook", hookEntry(event));
+				const runtime = resolveRuntime();
+				if (!runtime?.isCurrent()) return;
+				await start(runtime, execution);
+				const native = {
+					type: "tool_result",
+					toolCallId: event.toolCallId,
+					toolName: event.toolName,
+					input: event.args,
+					content: event.content,
+					details: event.details,
+					isError: event.isError
+				};
+				const key = `${STATUS_PREFIX}:${native.toolCallId}:post`;
+				try {
+					return (await dispatchHooks(runtime.session, scopeFor(runtime, execution), {
+						eventName: HOOK_EVENT.postToolUse,
+						event: native,
+						progress: (index, total) => execution.client.setStatus(key, `Running post-tool hooks for ${native.toolName} (${index + 1}/${total})...`)
+					})).toolResult;
+				} finally {
+					execution.client.setStatus(key, void 0);
+				}
+			}
+		},
+		agentSettled: {
+			event: "agent_settled",
+			handle: (event, execution) => execution.session.appendCustomEntry("doom-hook", hookEntry(event))
+		},
+		sessionShutdown: {
+			event: "session_shutdown",
+			async handle(_event, execution) {
+				const runtime = resolveRuntime();
+				if (runtime?.isCurrent() && !scopeFor(runtime, execution).isSubagent) {
+					let shutdown = shutdowns.get(runtime);
+					if (!shutdown) {
+						shutdown = runLifecycle(runtime, execution, HOOK_EVENT.sessionEnd).then(() => void 0);
+						shutdowns.set(runtime, shutdown);
+					}
+					await shutdown;
+				}
+				execution.client.setStatus("doom-hook", void 0);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/_lib/serverRoot.ts
+const createHookServerRoot = ({ agent, signal }) => {
+	if (!agent) throw new Error("Hook session requires the headless host.");
+	const execution = agent.context;
+	const binding = createHookBinding({}, {
+		sessionId: execution.sessionId,
+		isSubagent: Boolean(execution.environment[SUBAGENT_ENVIRONMENT_FLAG]),
+		cwd: execution.cwd,
+		repoRoot: execution.repoRoot,
+		get model() {
+			return execution.model;
+		},
+		async sendMessage(text, delivery) {
+			if (!execution.session.admitPrompt) throw new DoomHeadlessPromptAdmissionError("The session cannot admit a hook prompt.");
+			await execution.session.admitPrompt(text, delivery);
+		},
+		appendCustomEntry: (type, data) => execution.session.appendCustomEntry(type, data)
+	}, signal);
+	return {
+		value: createServerHooks(binding.runtime),
+		services: [binding.plugin]
+	};
+};
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/root.server.ts
+var root_server_default = defineRoot(createHookServerRoot);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/agent-end.server.ts
+var agent_end_server_default = defineHook(({ root }) => root.agentEnd);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/agent-settled.server.ts
+var agent_settled_server_default = defineHook(({ root }) => root.agentSettled);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/before-agent-start.server.ts
+var before_agent_start_server_default = defineHook(({ root }) => root.beforeAgentStart);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/session-shutdown.server.ts
+var session_shutdown_server_default = defineHook(({ root }) => root.sessionShutdown);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/session-start.server.ts
+var session_start_server_default = defineHook(({ root }) => root.sessionStart);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/tool-call.server.ts
+var tool_call_server_default = defineHook(({ root }) => root.toolCall);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/tool-result.server.ts
+var tool_result_server_default = defineHook(({ root }) => root.toolResult);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/po-author-hook.server.ts
+var po_author_hook_server_default = defineResource({
+	name: "po-author-hook",
+	description: "Author Po repository or plugin hooks. Use when creating or changing .po/hooks.yaml, selecting hook groups from modes.yaml, writing hook commands, or adapting Claude Code hook payloads and decisions to Po.",
+	when: DOOM_HELP_WHEN,
+	kind: "skill",
+	path: packageResourcePath(import.meta.url, "src/prompts/po-author-hook/SKILL.md"),
+	read: async () => {
+		const text = await readPackageResource(import.meta.url, "src/prompts/po-author-hook/SKILL.md");
+		if (!text.trim()) throw new Error("The installed hook-authoring skill is missing or unreadable.");
+		return text;
+	}
+});
+//#endregion
+//#region generated/server.ts
+const at = (value, context) => typeof value === "function" ? value(context) : value;
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const facet = defineServerPlugin({
+	name: "@agimon-ai/po-hook",
+	providerOverrides: composeServerProviderOverrides(root_server_default),
+	session: async (context) => {
+		const scopeSession = await root_server_default(context);
+		const contextSession = {
+			...context,
+			root: scopeSession.value
+		};
+		return {
+			...composeRootHooks(scopeSession),
+			get hooks() {
+				return [
+					via({ event: "agent_end" }, at(agent_end_server_default, contextSession)),
+					via({ event: "agent_settled" }, at(agent_settled_server_default, contextSession)),
+					via({ event: "before_agent_start" }, at(before_agent_start_server_default, contextSession)),
+					via({ event: "session_shutdown" }, at(session_shutdown_server_default, contextSession)),
+					via({ event: "session_start" }, at(session_start_server_default, contextSession)),
+					via({ event: "tool_call" }, at(tool_call_server_default, contextSession)),
+					via({ event: "tool_result" }, at(tool_result_server_default, contextSession))
+				];
+			},
+			get resources() {
+				return [at(po_author_hook_server_default, contextSession)];
+			},
+			services: [...scopeSession.services ?? []],
+			get activities() {
+				return [...scopeSession.activities ?? []];
+			}
+		};
+	}
+});
+//#endregion
+export { facet as default, facet };
+
+//# sourceMappingURL=server.mjs.map