@clinebot/core 0.0.37 → 0.0.38

package/src/hooks/hook-registry.ts

@@ -1,257 +0,0 @@
-/**
- * Lifecycle-hook registration wiring for the legacy `AgentHooks` and
- * `AgentExtension` surfaces onto a `HookEngine`.
- *
- * @see PLAN.md §3.1 — moved from `packages/agents/src/runtime/hook-registry.ts`.
- * @see PLAN.md §3.3.3 — OLD `config.hooks.*` → NEW placement.
- *
- * Verbatim port: pure wiring with no state. After the migration this is
- * invoked by `HookBridge` and the legacy-agent facade's `addTools`
- * pathway. Lives under `packages/core/src/hooks/` per §3.1.
- */
-
-import type {
-	AgentConfig,
-	AgentExtension,
-	AgentExtensionHookStage,
-	AgentHookControl,
-	HookEngine,
-	HookHandler,
-} from "@clinebot/shared";
-
-type LifecycleConfig = Pick<AgentConfig, "hooks" | "extensions">;
-
-type ExtensionStageHandlerSpec = {
-	handler: (
-		extension: AgentExtension,
-		event: { payload: unknown },
-	) => Promise<AgentHookControl | undefined> | AgentHookControl | undefined;
-	name: string;
-};
-
-const EXTENSION_STAGE_HANDLERS: Record<
-	AgentExtensionHookStage,
-	ExtensionStageHandlerSpec
-> = {
-	input: {
-		name: "onInput",
-		handler: (extension, event) =>
-			extension.onInput?.(event.payload as never) as
-				| AgentHookControl
-				| undefined,
-	},
-	session_start: {
-		name: "onSessionStart",
-		handler: (extension, event) =>
-			extension.onSessionStart?.(event.payload as never) as
-				| AgentHookControl
-				| undefined,
-	},
-	run_start: {
-		name: "onRunStart",
-		handler: (extension, event) =>
-			extension.onRunStart?.(event.payload as never) as
-				| AgentHookControl
-				| undefined,
-	},
-	iteration_start: {
-		name: "onIterationStart",
-		handler: (extension, event) =>
-			extension.onIterationStart?.(event.payload as never) as
-				| AgentHookControl
-				| undefined,
-	},
-	turn_start: {
-		name: "onTurnStart",
-		handler: (extension, event) =>
-			extension.onTurnStart?.(event.payload as never) as
-				| AgentHookControl
-				| undefined,
-	},
-	before_agent_start: {
-		name: "onBeforeAgentStart",
-		handler: (extension, event) =>
-			extension.onBeforeAgentStart?.(event.payload as never) as
-				| AgentHookControl
-				| undefined,
-	},
-	tool_call_before: {
-		name: "onToolCall",
-		handler: (extension, event) =>
-			extension.onToolCall?.(event.payload as never) as
-				| AgentHookControl
-				| undefined,
-	},
-	tool_call_after: {
-		name: "onToolResult",
-		handler: (extension, event) =>
-			extension.onToolResult?.(event.payload as never) as
-				| AgentHookControl
-				| undefined,
-	},
-	turn_end: {
-		name: "onTurnEnd",
-		handler: (extension, event) =>
-			extension.onTurnEnd?.(event.payload as never) as
-				| AgentHookControl
-				| undefined,
-	},
-	stop_error: {
-		name: "onAgentError",
-		handler: (extension, event) =>
-			extension.onAgentError?.(event.payload as never) as
-				| AgentHookControl
-				| undefined,
-	},
-	iteration_end: {
-		name: "onIterationEnd",
-		handler: async (extension, event) => {
-			await extension.onIterationEnd?.(event.payload as never);
-			return undefined;
-		},
-	},
-	run_end: {
-		name: "onRunEnd",
-		handler: async (extension, event) => {
-			await extension.onRunEnd?.(event.payload as never);
-			return undefined;
-		},
-	},
-	session_shutdown: {
-		name: "onSessionShutdown",
-		handler: (extension, event) =>
-			extension.onSessionShutdown?.(event.payload as never) as
-				| AgentHookControl
-				| undefined,
-	},
-	error: {
-		name: "onError",
-		handler: async (extension, event) => {
-			await extension.onError?.(event.payload as never);
-			return undefined;
-		},
-	},
-	runtime_event: {
-		name: "onRuntimeEvent",
-		handler: async (extension, event) => {
-			await extension.onRuntimeEvent?.(event.payload as never);
-			return undefined;
-		},
-	},
-};
-
-export function registerLifecycleHandlers(
-	hookEngine: HookEngine,
-	config: LifecycleConfig,
-): void {
-	const register = (handler: HookHandler): void => {
-		hookEngine.register(handler);
-	};
-	const hooks = config.hooks;
-	if (hooks?.onSessionStart)
-		register({
-			name: "hooks.onSessionStart",
-			stage: "session_start",
-			handle: (event) => hooks.onSessionStart?.(event.payload as never),
-		});
-	if (hooks?.onRunStart)
-		register({
-			name: "hooks.onRunStart",
-			stage: "run_start",
-			handle: (event) => hooks.onRunStart?.(event.payload as never),
-		});
-	if (hooks?.onRunEnd)
-		register({
-			name: "hooks.onRunEnd",
-			stage: "run_end",
-			handle: async (event) => {
-				await hooks.onRunEnd?.(event.payload as never);
-				return undefined;
-			},
-		});
-	if (hooks?.onIterationStart)
-		register({
-			name: "hooks.onIterationStart",
-			stage: "iteration_start",
-			handle: (event) => hooks.onIterationStart?.(event.payload as never),
-		});
-	if (hooks?.onIterationEnd)
-		register({
-			name: "hooks.onIterationEnd",
-			stage: "iteration_end",
-			handle: async (event) => {
-				await hooks.onIterationEnd?.(event.payload as never);
-				return undefined;
-			},
-		});
-	if (hooks?.onTurnStart)
-		register({
-			name: "hooks.onTurnStart",
-			stage: "turn_start",
-			handle: (event) => hooks.onTurnStart?.(event.payload as never),
-		});
-	if (hooks?.onBeforeAgentStart) {
-		register({
-			name: "hooks.onBeforeAgentStart",
-			stage: "before_agent_start",
-			handle: (event) => hooks.onBeforeAgentStart?.(event.payload as never),
-		});
-	}
-	if (hooks?.onTurnEnd) {
-		register({
-			name: "hooks.onTurnEnd",
-			stage: "turn_end",
-			handle: (event) => hooks.onTurnEnd?.(event.payload as never),
-		});
-	}
-	if (hooks?.onStopError)
-		register({
-			name: "hooks.onStopError",
-			stage: "stop_error",
-			handle: (event) => hooks.onStopError?.(event.payload as never),
-		});
-	if (hooks?.onToolCallStart)
-		register({
-			name: "hooks.onToolCallStart",
-			stage: "tool_call_before",
-			handle: (event) => hooks.onToolCallStart?.(event.payload as never),
-		});
-	if (hooks?.onToolCallEnd)
-		register({
-			name: "hooks.onToolCallEnd",
-			stage: "tool_call_after",
-			handle: (event) => hooks.onToolCallEnd?.(event.payload as never),
-		});
-	if (hooks?.onSessionShutdown)
-		register({
-			name: "hooks.onSessionShutdown",
-			stage: "session_shutdown",
-			handle: (event) => hooks.onSessionShutdown?.(event.payload as never),
-		});
-	if (hooks?.onError)
-		register({
-			name: "hooks.onError",
-			stage: "error",
-			handle: async (event) => {
-				await hooks.onError?.(event.payload as never);
-				return undefined;
-			},
-		});
-	for (const [index, extension] of (config.extensions ?? []).entries()) {
-		if (extension.disabled) continue;
-		if (!extension.manifest.capabilities.includes("hooks")) continue;
-		const order = String(index).padStart(4, "0");
-		const extensionName = extension.name || `extension_${order}`;
-		const base = `${order}:${extensionName}`;
-		const subscribedStages = new Set(extension.manifest.hookStages ?? []);
-		for (const stage of subscribedStages) {
-			const stageHandler = EXTENSION_STAGE_HANDLERS[stage];
-			if (!stageHandler) continue;
-			register({
-				name: `${base}.${stageHandler.name}`,
-				stage,
-				handle: (event) => stageHandler.handler(extension, event),
-			});
-		}
-	}
-}

package/src/hooks/index.ts

@@ -1,18 +0,0 @@
-export {
-	createSubprocessHooks,
-	type HookEventName,
-	HookEventNameSchema,
-	type HookEventPayload,
-	HookEventPayloadSchema,
-	parseHookEventPayload,
-	type RunHookOptions,
-	type RunHookResult,
-	runHook,
-	type SubprocessHookControl,
-	type SubprocessHooksOptions,
-} from "./subprocess";
-export {
-	type RunSubprocessEventOptions,
-	type RunSubprocessEventResult,
-	runSubprocessEvent,
-} from "./subprocess-runner";

package/src/hooks/subprocess-runner.ts

@@ -1,196 +0,0 @@
-import { spawn } from "node:child_process";
-import {
-	augmentNodeCommandForDebug,
-	withResolvedClineBuildEnv,
-} from "@clinebot/shared";
-
-export interface RunSubprocessEventOptions {
-	command: string[];
-	cwd?: string;
-	env?: NodeJS.ProcessEnv;
-	detached?: boolean;
-	timeoutMs?: number;
-	onSpawn?: (event: {
-		command: string[];
-		pid?: number;
-		detached: boolean;
-	}) => void;
-}
-
-export interface RunSubprocessEventResult {
-	exitCode: number | null;
-	stdout: string;
-	stderr: string;
-	parsedJson?: unknown;
-	parseError?: string;
-	timedOut?: boolean;
-}
-
-function parseStdout(stdout: string): {
-	parsedJson?: unknown;
-	parseError?: string;
-} {
-	const trimmed = stdout.trim();
-	if (!trimmed) {
-		return {};
-	}
-
-	const lines = trimmed
-		.split("\n")
-		.map((line) => line.trim())
-		.filter(Boolean);
-	const prefixed = lines
-		.filter((line) => line.startsWith("HOOK_CONTROL\t"))
-		.map((line) => line.slice("HOOK_CONTROL\t".length));
-
-	const candidate =
-		prefixed.length > 0 ? prefixed[prefixed.length - 1] : trimmed;
-	try {
-		return { parsedJson: JSON.parse(candidate) };
-	} catch (error) {
-		return {
-			parseError:
-				error instanceof Error
-					? error.message
-					: "Failed to parse subprocess stdout JSON",
-		};
-	}
-}
-
-function formatSpawnError(error: unknown, command: string[]): Error {
-	const err = error instanceof Error ? error : new Error(String(error));
-	const withCode = err as Error & { code?: string };
-	const commandLabel = command.join(" ");
-	if (withCode.code === "EACCES") {
-		return new Error(
-			`Failed to execute hook command "${commandLabel}" (EACCES). Configure hooks with an explicit interpreter/command array (for example: ["bash", "/path/to/script"]) or make the script executable with a valid shebang.`,
-		);
-	}
-	return new Error(
-		`Failed to execute hook command "${commandLabel}": ${err.message}`,
-	);
-}
-
-async function writeToChildStdin(
-	child: ReturnType<typeof spawn>,
-	payload: string,
-): Promise<void> {
-	const stdin = child.stdin;
-	if (!stdin) {
-		throw new Error("runSubprocessEvent failed to create stdin pipe");
-	}
-
-	await new Promise<void>((resolve, reject) => {
-		const onError = (error: Error) => {
-			stdin.off("error", onError);
-			const code = (error as Error & { code?: string }).code;
-			if (code === "EPIPE" || code === "ERR_STREAM_DESTROYED") {
-				resolve();
-				return;
-			}
-			reject(error);
-		};
-		stdin.once("error", onError);
-		stdin.end(payload, (error?: Error | null) => {
-			stdin.off("error", onError);
-			if (error) {
-				const code = (error as Error & { code?: string }).code;
-				if (code === "EPIPE" || code === "ERR_STREAM_DESTROYED") {
-					resolve();
-					return;
-				}
-				reject(error);
-				return;
-			}
-			resolve();
-		});
-	});
-}
-
-export async function runSubprocessEvent(
-	payload: unknown,
-	options: RunSubprocessEventOptions,
-): Promise<RunSubprocessEventResult | undefined> {
-	const command = augmentNodeCommandForDebug(options.command, {
-		env: options.env,
-		debugRole: "hook",
-	});
-	if (!Array.isArray(command) || command.length === 0) {
-		throw new Error("runSubprocessEvent requires a non-empty command");
-	}
-
-	const detached = !!options.detached;
-	const child = spawn(command[0], command.slice(1), {
-		cwd: options.cwd,
-		env: withResolvedClineBuildEnv(options.env),
-		stdio: detached ? ["pipe", "ignore", "ignore"] : ["pipe", "pipe", "pipe"],
-		detached,
-	});
-	const spawned = new Promise<void>((resolve) => {
-		child.once("spawn", () => {
-			try {
-				options.onSpawn?.({
-					command,
-					pid: child.pid ?? undefined,
-					detached,
-				});
-			} catch {
-				// Logging callbacks must not break subprocess execution.
-			}
-			resolve();
-		});
-	});
-	const childError = new Promise<never>((_, reject) => {
-		child.once("error", (error) => {
-			reject(formatSpawnError(error, command));
-		});
-	});
-
-	await writeToChildStdin(child, JSON.stringify(payload));
-
-	if (detached) {
-		await Promise.race([spawned, childError]);
-		child.unref();
-		return;
-	}
-
-	if (!child.stdout || !child.stderr) {
-		throw new Error("runSubprocessEvent failed to create stdout/stderr pipes");
-	}
-
-	let stdout = "";
-	let stderr = "";
-	let timedOut = false;
-	let timeoutId: NodeJS.Timeout | undefined;
-
-	child.stdout.on("data", (chunk: Buffer | string) => {
-		stdout += chunk.toString();
-	});
-	child.stderr.on("data", (chunk: Buffer | string) => {
-		stderr += chunk.toString();
-	});
-
-	const result = new Promise<RunSubprocessEventResult>((resolve) => {
-		if ((options.timeoutMs ?? 0) > 0) {
-			timeoutId = setTimeout(() => {
-				timedOut = true;
-				child.kill("SIGKILL");
-			}, options.timeoutMs);
-		}
-		child.once("close", (exitCode) => {
-			if (timeoutId) {
-				clearTimeout(timeoutId);
-			}
-			const { parsedJson, parseError } = parseStdout(stdout);
-			resolve({
-				exitCode,
-				stdout,
-				stderr,
-				parsedJson,
-				parseError,
-				timedOut,
-			});
-		});
-	});
-	return await Promise.race([result, childError]);
-}