@clinebot/core 0.0.6 → 0.0.10

package/src/runtime/hook-file-hooks.ts

@@ -30,6 +30,9 @@ type AgentHookToolCallEndContext = Parameters<
 type AgentHookTurnEndContext = Parameters<
 	NonNullable<AgentHooks["onTurnEnd"]>
 >[0];
+type AgentHookStopErrorContext = Parameters<
+	NonNullable<AgentHooks["onStopError"]>
+>[0];
 type AgentHookSessionShutdownContext = Parameters<
 	NonNullable<AgentHooks["onSessionShutdown"]>
 >[0];
@@ -201,6 +204,43 @@ function parseHookStdout(stdout: string): {
 	}
 }
 
+async function writeToChildStdin(
+	child: ReturnType<typeof spawn>,
+	body: string,
+): Promise<void> {
+	const stdin = child.stdin;
+	if (!stdin) {
+		throw new Error("hook command failed to create stdin");
+	}
+
+	await new Promise<void>((resolve, reject) => {
+		let settled = false;
+		const finish = (error?: Error | null) => {
+			if (settled) {
+				return;
+			}
+			settled = true;
+			stdin.off("error", onError);
+			stdin.off("close", onClose);
+			if (error) {
+				const code = (error as Error & { code?: string }).code;
+				if (code === "EPIPE" || code === "ERR_STREAM_DESTROYED") {
+					resolve();
+					return;
+				}
+				reject(error);
+				return;
+			}
+			resolve();
+		};
+		const onError = (error: Error) => finish(error);
+		const onClose = () => finish();
+		stdin.on("error", onError);
+		stdin.once("close", onClose);
+		stdin.end(body, (error?: Error | null) => finish(error));
+	});
+}
+
 async function runHookCommand(
 	payload: HookEventPayload,
 	options: {
@@ -222,19 +262,18 @@ async function runHookCommand(
 			: ["pipe", "pipe", "pipe"],
 		detached: options.detached,
 	});
+	const spawned = new Promise<void>((resolve) => {
+		child.once("spawn", () => resolve());
+	});
+	const childError = new Promise<never>((_, reject) => {
+		child.once("error", (error) => reject(error));
+	});
 
 	const body = JSON.stringify(payload);
-	if (!child.stdin) {
-		throw new Error("hook command failed to create stdin");
-	}
-	child.stdin.write(body);
-	child.stdin.end();
+	await writeToChildStdin(child, body);
 
 	if (options.detached) {
-		await new Promise<void>((resolve, reject) => {
-			child.once("error", reject);
-			child.once("spawn", () => resolve());
-		});
+		await Promise.race([spawned, childError]);
 		child.unref();
 		return;
 	}
@@ -253,8 +292,7 @@ async function runHookCommand(
 		stderr += chunk.toString();
 	});
 
-	return await new Promise<HookCommandResult>((resolve, reject) => {
-		child.once("error", reject);
+	const result = new Promise<HookCommandResult>((resolve) => {
 		if ((options.timeoutMs ?? 0) > 0) {
 			timeoutId = setTimeout(() => {
 				timedOut = true;
@@ -276,6 +314,7 @@ async function runHookCommand(
 			});
 		});
 	});
+	return await Promise.race([result, childError]);
 }
 
 function parseShebangCommand(path: string): string[] | undefined {
@@ -491,6 +530,19 @@ export function createHookAuditHooks(options: {
 			});
 			return undefined;
 		},
+		onStopError: async (ctx: AgentHookStopErrorContext) => {
+			append({
+				...createPayloadBase(ctx, runtimeOptions),
+				hookName: "agent_error",
+				iteration: ctx.iteration,
+				error: {
+					name: ctx.error.name,
+					message: ctx.error.message,
+					stack: ctx.error.stack,
+				},
+			});
+			return undefined;
+		},
 		onSessionShutdown: async (ctx: AgentHookSessionShutdownContext) => {
 			if (isAbortReason(ctx.reason)) {
 				append({
@@ -634,6 +686,30 @@ export function createHookConfigFileHooks(
 		});
 	};
 
+	const runStopError = async (
+		ctx: AgentHookStopErrorContext,
+	): Promise<void> => {
+		const commandPaths = commandMap.agent_error ?? [];
+		if (commandPaths.length === 0) {
+			return;
+		}
+		runAsyncHookCommands({
+			commands: commandPaths,
+			cwd: options.cwd,
+			logger: options.logger,
+			payload: {
+				...createPayloadBase(ctx, options),
+				hookName: "agent_error",
+				iteration: ctx.iteration,
+				error: {
+					name: ctx.error.name,
+					message: ctx.error.message,
+					stack: ctx.error.stack,
+				},
+			},
+		});
+	};
+
 	const runSessionShutdown = async (
 		ctx: AgentHookSessionShutdownContext,
 	): Promise<void> => {
@@ -684,6 +760,10 @@ export function createHookConfigFileHooks(
 			await runTurnEnd(ctx);
 			return undefined;
 		},
+		onStopError: async (ctx: AgentHookStopErrorContext) => {
+			await runStopError(ctx);
+			return undefined;
+		},
 		onSessionShutdown: async (ctx: AgentHookSessionShutdownContext) => {
 			await runSessionShutdown(ctx);
 			return undefined;

package/src/runtime/session-runtime.ts

@@ -40,7 +40,7 @@ export interface RuntimeBuilder {
 export interface SessionRuntime {
 	start(config: CoreSessionConfig): Promise<{ sessionId: string }>;
 	send(sessionId: string, prompt: string): Promise<AgentResult | undefined>;
-	abort(sessionId: string): Promise<void>;
+	abort(sessionId: string, reason?: unknown): Promise<void>;
 	stop(sessionId: string): Promise<void>;
 	poll(): Promise<string[]>;
 }

package/src/session/default-session-manager.e2e.test.ts

@@ -10,7 +10,7 @@ import {
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { AgentResult } from "@clinebot/agents";
-import type { providers as LlmsProviders } from "@clinebot/llms";
+import type { LlmsProviders } from "@clinebot/llms";
 import { nanoid } from "nanoid";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import type { SessionSource, SessionStatus } from "../types/common";
@@ -348,6 +348,7 @@ describe("DefaultSessionManager e2e", () => {
 		await manager.stop(started.sessionId);
 		const stopped = await manager.get(started.sessionId);
 		expect(stopped?.status).toBe("cancelled");
+		expect(stopped?.exitCode).toBe(0);
 		expect(agentShutdown).toHaveBeenCalledTimes(1);
 		expect(runtimeShutdown).toHaveBeenCalledTimes(1);
 		const parsedManifest = JSON.parse(