@clinebot/core 0.0.35 → 0.0.36

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

@@ -6,6 +6,7 @@ import {
 	augmentNodeCommandForDebug,
 	type BasicLogger,
 	type HookSessionContext,
+	type WorkspaceInfo,
 	withResolvedClineBuildEnv,
 } from "@clinebot/shared";
 import { ensureHookLogDir } from "@clinebot/shared/storage";
@@ -46,6 +47,8 @@ type HookRuntimeOptions = {
 	rootSessionId?: string;
 	logger?: BasicLogger;
 	toolCallTimeoutMs?: number;
+	/** Structured git + path metadata forwarded into every hook payload. */
+	workspaceInfo?: WorkspaceInfo;
 };
 
 function mapParams(input: unknown): Record<string, string> {
@@ -162,6 +165,7 @@ function createPayloadBase(
 		taskId: ctx.conversationId,
 		sessionContext,
 		workspaceRoots: options.workspacePath ? [options.workspacePath] : [],
+		workspaceInfo: options.workspaceInfo,
 		userId,
 		agent_id: ctx.agentId,
 		parent_agent_id: ctx.parentAgentId,
@@ -270,7 +274,7 @@ async function runHookCommand(
 	}
 	const command = augmentNodeCommandForDebug(options.command, {
 		env: options.env,
-		debugRole: "hook-worker",
+		debugRole: "hook",
 	});
 	const child = spawn(command[0], command.slice(1), {
 		cwd: options.cwd,
@@ -395,7 +399,7 @@ function inferHookCommand(path: string): string[] {
 		lowered.endsWith(".cjs")
 	) {
 		return augmentNodeCommandForDebug(["node", path], {
-			debugRole: "hook-worker",
+			debugRole: "hook",
 		});
 	}
 	if (
@@ -500,11 +504,13 @@ function runAsyncHookCommands(options: {
 export function createHookAuditHooks(options: {
 	rootSessionId?: string;
 	workspacePath: string;
+	workspaceInfo?: WorkspaceInfo;
 }): AgentHooks {
 	const runtimeOptions: HookRuntimeOptions = {
 		cwd: options.workspacePath,
 		workspacePath: options.workspacePath,
 		rootSessionId: options.rootSessionId,
+		workspaceInfo: options.workspaceInfo,
 	};
 
 	const append = (payload: HookEventPayload): void => {

package/src/hooks/index.ts

@@ -1,10 +1,3 @@
-export {
-	createPersistentSubprocessHooks,
-	PersistentHookClient,
-	type PersistentHookClientOptions,
-	type PersistentSubprocessHookControl,
-	type PersistentSubprocessHooksOptions,
-} from "./persistent";
 export {
 	createSubprocessHooks,
 	type HookEventName,

package/src/hooks/subprocess-runner.ts

@@ -113,7 +113,7 @@ export async function runSubprocessEvent(
 ): Promise<RunSubprocessEventResult | undefined> {
 	const command = augmentNodeCommandForDebug(options.command, {
 		env: options.env,
-		debugRole: "hook-worker",
+		debugRole: "hook",
 	});
 	if (!Array.isArray(command) || command.length === 0) {
 		throw new Error("runSubprocessEvent requires a non-empty command");

package/src/hooks/subprocess.ts

@@ -26,6 +26,7 @@ import {
 	type ToolCallHookPayload,
 	type ToolResultHookPayload,
 	type UserPromptSubmitData,
+	type WorkspaceInfo,
 } from "@clinebot/shared";
 import { z } from "zod";
 import {
@@ -133,6 +134,13 @@ export async function runHook(
 export interface SubprocessHooksOptions {
 	command?: string[];
 	cwd?: string;
+	/**
+	 * Structured workspace and git metadata forwarded into every hook payload
+	 * as `workspaceInfo`. Obtained from `generateWorkspaceInfo` at session
+	 * startup and passed here so hook scripts can inspect branch, commit, and
+	 * remote without running their own `git` commands.
+	 */
+	workspaceInfo?: WorkspaceInfo;
 	env?: NodeJS.ProcessEnv;
 	timeoutMs?: number;
 	onDispatchError?: (error: Error, payload: HookEventPayload) => void;
@@ -240,6 +248,7 @@ function basePayload(
 			parentAgentId: ctx.parentAgentId,
 		}),
 		workspaceRoots: workspaceRoot ? [workspaceRoot] : [],
+		workspaceInfo: options.workspaceInfo,
 		userId,
 		agent_id: ctx.agentId,
 		parent_agent_id: ctx.parentAgentId,

package/src/hub/browser-websocket.ts

@@ -0,0 +1,137 @@
+import type {
+	HubClientRegistration,
+	HubEventEnvelope,
+	HubReplyEnvelope,
+	HubTransportFrame,
+} from "@clinebot/shared";
+import type { HubCommandTransport } from "./transport";
+
+export interface BrowserHubSocketLike {
+	send(data: string): void;
+	addEventListener(
+		type: "message",
+		listener: (event: { data: string }) => void,
+	): void;
+	addEventListener(type: "close", listener: () => void): void;
+	removeEventListener(
+		type: "message",
+		listener: (event: { data: string }) => void,
+	): void;
+	removeEventListener(type: "close", listener: () => void): void;
+}
+
+export class BrowserWebSocketHubAdapter {
+	constructor(private readonly transport: HubCommandTransport) {}
+
+	attach(socket: BrowserHubSocketLike): () => void {
+		const subscriptions = new Map<string, () => void>();
+		const registeredClientIds = new Set<string>();
+		let closed = false;
+
+		const sendFrame = (frame: HubTransportFrame): void => {
+			socket.send(JSON.stringify(frame));
+		};
+
+		const onEvent = (envelope: HubEventEnvelope): void => {
+			sendFrame({ kind: "event", envelope });
+		};
+
+		const onMessage = async (event: { data: string }): Promise<void> => {
+			const frame = JSON.parse(event.data) as HubTransportFrame;
+			try {
+				switch (frame.kind) {
+					case "command": {
+						const reply = await this.transport.command(frame.envelope);
+						if (frame.envelope.command === "client.register" && reply.ok) {
+							const registration = (frame.envelope.payload ??
+								{}) as unknown as HubClientRegistration;
+							const clientId =
+								registration.clientId?.trim() ||
+								frame.envelope.clientId?.trim();
+							if (clientId) {
+								registeredClientIds.add(clientId);
+							}
+						} else if (
+							frame.envelope.command === "client.unregister" &&
+							reply.ok
+						) {
+							const clientId = frame.envelope.clientId?.trim();
+							if (clientId) {
+								registeredClientIds.delete(clientId);
+							}
+						}
+						sendFrame({
+							kind: "reply",
+							envelope: reply satisfies HubReplyEnvelope,
+						});
+						break;
+					}
+					case "stream.subscribe": {
+						const key = `${frame.clientId}:${frame.sessionId ?? "*"}`;
+						if (subscriptions.has(key)) {
+							break;
+						}
+						const unsubscribe = await this.transport.subscribe(
+							frame.clientId,
+							onEvent,
+							{ sessionId: frame.sessionId },
+						);
+						subscriptions.set(key, unsubscribe);
+						break;
+					}
+					case "stream.unsubscribe": {
+						const key = `${frame.clientId}:${frame.sessionId ?? "*"}`;
+						subscriptions.get(key)?.();
+						subscriptions.delete(key);
+						break;
+					}
+					case "reply":
+					case "event":
+						break;
+				}
+			} catch (error) {
+				if (frame.kind !== "command") {
+					return;
+				}
+				sendFrame({
+					kind: "reply",
+					envelope: {
+						...frame.envelope,
+						ok: false,
+						error: {
+							code: "command_failed",
+							message:
+								error instanceof Error ? error.message : "Unknown hub error",
+						},
+					} satisfies HubReplyEnvelope,
+				});
+			}
+		};
+
+		const onClose = (): void => {
+			if (closed) {
+				return;
+			}
+			closed = true;
+			for (const unsubscribe of subscriptions.values()) {
+				unsubscribe();
+			}
+			subscriptions.clear();
+			for (const clientId of registeredClientIds) {
+				void this.transport.command({
+					version: "v1",
+					command: "client.unregister",
+					clientId,
+				});
+			}
+			registeredClientIds.clear();
+			socket.removeEventListener("message", onMessage);
+			socket.removeEventListener("close", onClose);
+		};
+
+		socket.addEventListener("message", onMessage);
+		socket.addEventListener("close", onClose);
+
+		return onClose;
+	}
+}