remoteclaw 0.1.0-next.da482d8 → 0.1.0-next.db8a792

package/dist/hook-runner-global-BztoD8lu.js

@@ -0,0 +1,527 @@
+import { o as createSubsystemLogger } from "./entry.js";
+import { g as normalizeOptionalAccountId } from "./session-key-BF-9YzxC.js";
+import { t as getChannelDock } from "./dock-CpNmmysM.js";
+import { P as parseInlineDirectives } from "./sessions-DDIoP7Rl.js";
+import { r as normalizeChannelId, t as getChannelPlugin } from "./plugins-DdMgSc_b.js";
+import { t as isMessagingToolDuplicate } from "./agent-helpers-D83kfcF9.js";
+
+//#region src/infra/outbound/target-normalization.ts
+function normalizeChannelTargetInput(raw) {
+	return raw.trim();
+}
+function normalizeTargetForProvider(provider, raw) {
+	if (!raw) return;
+	const providerId = normalizeChannelId(provider);
+	return ((providerId ? getChannelPlugin(providerId) : void 0)?.messaging?.normalizeTarget?.(raw) ?? (raw.trim() || void 0)) || void 0;
+}
+function buildTargetResolverSignature(channel) {
+	const resolver = getChannelPlugin(channel)?.messaging?.targetResolver;
+	const hint = resolver?.hint ?? "";
+	const looksLike = resolver?.looksLikeId;
+	return hashSignature(`${hint}|${looksLike ? looksLike.toString() : ""}`);
+}
+function hashSignature(value) {
+	let hash = 5381;
+	for (let i = 0; i < value.length; i += 1) hash = (hash << 5) + hash ^ value.charCodeAt(i);
+	return (hash >>> 0).toString(36);
+}
+
+//#endregion
+//#region src/auto-reply/reply/reply-tags.ts
+function extractReplyToTag(text, currentMessageId) {
+	const result = parseInlineDirectives(text, {
+		currentMessageId,
+		stripAudioTag: false
+	});
+	return {
+		cleaned: result.text,
+		replyToId: result.replyToId,
+		replyToCurrent: result.replyToCurrent,
+		hasTag: result.hasReplyTag
+	};
+}
+
+//#endregion
+//#region src/auto-reply/reply/reply-threading.ts
+function resolveReplyToMode(cfg, channel, accountId, chatType) {
+	const provider = normalizeChannelId(channel);
+	if (!provider) return "all";
+	return getChannelDock(provider)?.threading?.resolveReplyToMode?.({
+		cfg,
+		accountId,
+		chatType
+	}) ?? "all";
+}
+function createReplyToModeFilter(mode, opts = {}) {
+	let hasThreaded = false;
+	return (payload) => {
+		if (!payload.replyToId) return payload;
+		if (mode === "off") {
+			const isExplicit = Boolean(payload.replyToTag) || Boolean(payload.replyToCurrent);
+			if (opts.allowExplicitReplyTagsWhenOff && isExplicit) return payload;
+			return {
+				...payload,
+				replyToId: void 0
+			};
+		}
+		if (mode === "all") return payload;
+		if (hasThreaded) return {
+			...payload,
+			replyToId: void 0
+		};
+		hasThreaded = true;
+		return payload;
+	};
+}
+function createReplyToModeFilterForChannel(mode, channel) {
+	const provider = normalizeChannelId(channel);
+	const isWebchat = (typeof channel === "string" ? channel.trim().toLowerCase() : void 0) === "webchat";
+	const dock = provider ? getChannelDock(provider) : void 0;
+	return createReplyToModeFilter(mode, { allowExplicitReplyTagsWhenOff: provider ? dock?.threading?.allowExplicitReplyTagsWhenOff ?? dock?.threading?.allowTagsWhenOff ?? true : isWebchat });
+}
+
+//#endregion
+//#region src/auto-reply/reply/reply-payloads.ts
+function resolveReplyThreadingForPayload(params) {
+	const implicitReplyToId = params.implicitReplyToId?.trim() || void 0;
+	const currentMessageId = params.currentMessageId?.trim() || void 0;
+	let resolved = params.payload.replyToId || params.payload.replyToCurrent === false || !implicitReplyToId ? params.payload : {
+		...params.payload,
+		replyToId: implicitReplyToId
+	};
+	if (typeof resolved.text === "string" && resolved.text.includes("[[")) {
+		const { cleaned, replyToId, replyToCurrent, hasTag } = extractReplyToTag(resolved.text, currentMessageId);
+		resolved = {
+			...resolved,
+			text: cleaned ? cleaned : void 0,
+			replyToId: replyToId ?? resolved.replyToId,
+			replyToTag: hasTag || resolved.replyToTag,
+			replyToCurrent: replyToCurrent || resolved.replyToCurrent
+		};
+	}
+	if (resolved.replyToCurrent && !resolved.replyToId && currentMessageId) resolved = {
+		...resolved,
+		replyToId: currentMessageId
+	};
+	return resolved;
+}
+function applyReplyTagsToPayload(payload, currentMessageId) {
+	return resolveReplyThreadingForPayload({
+		payload,
+		currentMessageId
+	});
+}
+function isRenderablePayload(payload) {
+	return Boolean(payload.text || payload.mediaUrl || payload.mediaUrls && payload.mediaUrls.length > 0 || payload.audioAsVoice || payload.channelData);
+}
+function shouldSuppressReasoningPayload(payload) {
+	return payload.isReasoning === true;
+}
+function applyReplyThreading(params) {
+	const { payloads, replyToMode, replyToChannel, currentMessageId } = params;
+	const applyReplyToMode = createReplyToModeFilterForChannel(replyToMode, replyToChannel);
+	const implicitReplyToId = currentMessageId?.trim() || void 0;
+	return payloads.map((payload) => resolveReplyThreadingForPayload({
+		payload,
+		implicitReplyToId,
+		currentMessageId
+	})).filter(isRenderablePayload).map(applyReplyToMode);
+}
+function filterMessagingToolDuplicates(params) {
+	const { payloads, sentTexts } = params;
+	if (sentTexts.length === 0) return payloads;
+	return payloads.filter((payload) => !isMessagingToolDuplicate(payload.text ?? "", sentTexts));
+}
+function filterMessagingToolMediaDuplicates(params) {
+	const normalizeMediaForDedupe = (value) => {
+		const trimmed = value.trim();
+		if (!trimmed) return "";
+		if (!trimmed.toLowerCase().startsWith("file://")) return trimmed;
+		try {
+			const parsed = new URL(trimmed);
+			if (parsed.protocol === "file:") return decodeURIComponent(parsed.pathname || "");
+		} catch {}
+		return trimmed.replace(/^file:\/\//i, "");
+	};
+	const { payloads, sentMediaUrls } = params;
+	if (sentMediaUrls.length === 0) return payloads;
+	const sentSet = new Set(sentMediaUrls.map(normalizeMediaForDedupe).filter(Boolean));
+	return payloads.map((payload) => {
+		const mediaUrl = payload.mediaUrl;
+		const mediaUrls = payload.mediaUrls;
+		const stripSingle = mediaUrl && sentSet.has(normalizeMediaForDedupe(mediaUrl));
+		const filteredUrls = mediaUrls?.filter((u) => !sentSet.has(normalizeMediaForDedupe(u)));
+		if (!stripSingle && (!mediaUrls || filteredUrls?.length === mediaUrls.length)) return payload;
+		return {
+			...payload,
+			mediaUrl: stripSingle ? void 0 : mediaUrl,
+			mediaUrls: filteredUrls?.length ? filteredUrls : void 0
+		};
+	});
+}
+function shouldSuppressMessagingToolReplies(params) {
+	const provider = params.messageProvider?.trim().toLowerCase();
+	if (!provider) return false;
+	const originTarget = normalizeTargetForProvider(provider, params.originatingTo);
+	if (!originTarget) return false;
+	const originAccount = normalizeOptionalAccountId(params.accountId);
+	const sentTargets = params.messagingToolSentTargets ?? [];
+	if (sentTargets.length === 0) return false;
+	return sentTargets.some((target) => {
+		if (!target?.provider) return false;
+		if (target.provider.trim().toLowerCase() !== provider) return false;
+		const targetKey = normalizeTargetForProvider(provider, target.to);
+		if (!targetKey) return false;
+		const targetAccount = normalizeOptionalAccountId(target.accountId);
+		if (originAccount && targetAccount && originAccount !== targetAccount) return false;
+		return targetKey === originTarget;
+	});
+}
+
+//#endregion
+//#region src/plugins/hooks.ts
+/**
+* Get hooks for a specific hook name, sorted by priority (higher first).
+*/
+function getHooksForName(registry, hookName) {
+	return registry.typedHooks.filter((h) => h.hookName === hookName).toSorted((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+}
+/**
+* Create a hook runner for a specific registry.
+*/
+function createHookRunner(registry, options = {}) {
+	const logger = options.logger;
+	const catchErrors = options.catchErrors ?? true;
+	const mergeSubagentSpawningResult = (acc, next) => {
+		if (acc?.status === "error") return acc;
+		if (next.status === "error") return next;
+		return {
+			status: "ok",
+			threadBindingReady: Boolean(acc?.threadBindingReady || next.threadBindingReady)
+		};
+	};
+	const mergeSubagentDeliveryTargetResult = (acc, next) => {
+		if (acc?.origin) return acc;
+		return next;
+	};
+	const handleHookError = (params) => {
+		const msg = `[hooks] ${params.hookName} handler from ${params.pluginId} failed: ${String(params.error)}`;
+		if (catchErrors) {
+			logger?.error(msg);
+			return;
+		}
+		throw new Error(msg, { cause: params.error });
+	};
+	/**
+	* Run a hook that doesn't return a value (fire-and-forget style).
+	* All handlers are executed in parallel for performance.
+	*/
+	async function runVoidHook(hookName, event, ctx) {
+		const hooks = getHooksForName(registry, hookName);
+		if (hooks.length === 0) return;
+		logger?.debug?.(`[hooks] running ${hookName} (${hooks.length} handlers)`);
+		const promises = hooks.map(async (hook) => {
+			try {
+				await hook.handler(event, ctx);
+			} catch (err) {
+				handleHookError({
+					hookName,
+					pluginId: hook.pluginId,
+					error: err
+				});
+			}
+		});
+		await Promise.all(promises);
+	}
+	/**
+	* Run a hook that can return a modifying result.
+	* Handlers are executed sequentially in priority order, and results are merged.
+	*/
+	async function runModifyingHook(hookName, event, ctx, mergeResults) {
+		const hooks = getHooksForName(registry, hookName);
+		if (hooks.length === 0) return;
+		logger?.debug?.(`[hooks] running ${hookName} (${hooks.length} handlers, sequential)`);
+		let result;
+		for (const hook of hooks) try {
+			const handlerResult = await hook.handler(event, ctx);
+			if (handlerResult !== void 0 && handlerResult !== null) if (mergeResults && result !== void 0) result = mergeResults(result, handlerResult);
+			else result = handlerResult;
+		} catch (err) {
+			handleHookError({
+				hookName,
+				pluginId: hook.pluginId,
+				error: err
+			});
+		}
+		return result;
+	}
+	/**
+	* Run before_reset hook.
+	* Fired when /new or /reset clears a session, before messages are lost.
+	* Runs in parallel (fire-and-forget).
+	*/
+	async function runBeforeReset(event, ctx) {
+		return runVoidHook("before_reset", event, ctx);
+	}
+	/**
+	* Run message_received hook.
+	* Runs in parallel (fire-and-forget).
+	*/
+	async function runMessageReceived(event, ctx) {
+		return runVoidHook("message_received", event, ctx);
+	}
+	/**
+	* Run message_sending hook.
+	* Allows plugins to modify or cancel outgoing messages.
+	* Runs sequentially.
+	*/
+	async function runMessageSending(event, ctx) {
+		return runModifyingHook("message_sending", event, ctx, (acc, next) => ({
+			content: next.content ?? acc?.content,
+			cancel: next.cancel ?? acc?.cancel
+		}));
+	}
+	/**
+	* Run message_sent hook.
+	* Runs in parallel (fire-and-forget).
+	*/
+	async function runMessageSent(event, ctx) {
+		return runVoidHook("message_sent", event, ctx);
+	}
+	/**
+	* Run before_tool_call hook.
+	* Allows plugins to modify or block tool calls.
+	* Runs sequentially.
+	*/
+	async function runBeforeToolCall(event, ctx) {
+		return runModifyingHook("before_tool_call", event, ctx, (acc, next) => ({
+			params: next.params ?? acc?.params,
+			block: next.block ?? acc?.block,
+			blockReason: next.blockReason ?? acc?.blockReason
+		}));
+	}
+	/**
+	* Run after_tool_call hook.
+	* Runs in parallel (fire-and-forget).
+	*/
+	async function runAfterToolCall(event, ctx) {
+		return runVoidHook("after_tool_call", event, ctx);
+	}
+	/**
+	* Run before_message_write hook.
+	*
+	* This hook is intentionally synchronous: it runs on the hot path where
+	* session transcripts are appended synchronously.
+	*
+	* Handlers are executed sequentially in priority order (higher first).
+	* If any handler returns { block: true }, the message is NOT written
+	* to the session JSONL and we return immediately.
+	* If a handler returns { message }, the modified message replaces the
+	* original for subsequent handlers and the final write.
+	*/
+	function runBeforeMessageWrite(event, ctx) {
+		const hooks = getHooksForName(registry, "before_message_write");
+		if (hooks.length === 0) return;
+		let current = event.message;
+		for (const hook of hooks) try {
+			const out = hook.handler({
+				...event,
+				message: current
+			}, ctx);
+			if (out && typeof out.then === "function") {
+				const msg = `[hooks] before_message_write handler from ${hook.pluginId} returned a Promise; this hook is synchronous and the result was ignored.`;
+				if (catchErrors) {
+					logger?.warn?.(msg);
+					continue;
+				}
+				throw new Error(msg);
+			}
+			const result = out;
+			if (result?.block) return { block: true };
+			if (result?.message) current = result.message;
+		} catch (err) {
+			const msg = `[hooks] before_message_write handler from ${hook.pluginId} failed: ${String(err)}`;
+			if (catchErrors) logger?.error(msg);
+			else throw new Error(msg, { cause: err });
+		}
+		if (current !== event.message) return { message: current };
+	}
+	/**
+	* Run session_start hook.
+	* Runs in parallel (fire-and-forget).
+	*/
+	async function runSessionStart(event, ctx) {
+		return runVoidHook("session_start", event, ctx);
+	}
+	/**
+	* Run session_end hook.
+	* Runs in parallel (fire-and-forget).
+	*/
+	async function runSessionEnd(event, ctx) {
+		return runVoidHook("session_end", event, ctx);
+	}
+	/**
+	* Run subagent_spawning hook.
+	* Runs sequentially so channel plugins can deterministically provision session bindings.
+	*/
+	async function runSubagentSpawning(event, ctx) {
+		return runModifyingHook("subagent_spawning", event, ctx, mergeSubagentSpawningResult);
+	}
+	/**
+	* Run subagent_delivery_target hook.
+	* Runs sequentially so channel plugins can deterministically resolve routing.
+	*/
+	async function runSubagentDeliveryTarget(event, ctx) {
+		return runModifyingHook("subagent_delivery_target", event, ctx, mergeSubagentDeliveryTargetResult);
+	}
+	/**
+	* Run subagent_spawned hook.
+	* Runs in parallel (fire-and-forget).
+	*/
+	async function runSubagentSpawned(event, ctx) {
+		return runVoidHook("subagent_spawned", event, ctx);
+	}
+	/**
+	* Run subagent_ended hook.
+	* Runs in parallel (fire-and-forget).
+	*/
+	async function runSubagentEnded(event, ctx) {
+		return runVoidHook("subagent_ended", event, ctx);
+	}
+	/**
+	* Run gateway_start hook.
+	* Runs in parallel (fire-and-forget).
+	*/
+	async function runGatewayStart(event, ctx) {
+		return runVoidHook("gateway_start", event, ctx);
+	}
+	/**
+	* Run gateway_stop hook.
+	* Runs in parallel (fire-and-forget).
+	*/
+	async function runGatewayStop(event, ctx) {
+		return runVoidHook("gateway_stop", event, ctx);
+	}
+	/**
+	* Run before_runtime_spawn hook.
+	* Fired before the CLI subprocess starts. Extensions can modify env, args, workspaceDir.
+	* Runs sequentially (modifiable).
+	*/
+	async function runBeforeRuntimeSpawn(event, ctx) {
+		return runModifyingHook("before_runtime_spawn", event, ctx, (acc, next) => ({
+			env: next.env ?? acc?.env,
+			workspaceDir: next.workspaceDir ?? acc?.workspaceDir
+		}));
+	}
+	/**
+	* Run after_runtime_exit hook.
+	* Fired after the CLI subprocess exits. Observe-only.
+	* Runs in parallel (fire-and-forget).
+	*/
+	async function runAfterRuntimeExit(event, ctx) {
+		return runVoidHook("after_runtime_exit", event, ctx);
+	}
+	/**
+	* Run session_resumed hook.
+	* Fired when an existing session ID is found for the channel conversation.
+	* Runs in parallel (fire-and-forget).
+	*/
+	async function runSessionResumed(event, ctx) {
+		return runVoidHook("session_resumed", event, ctx);
+	}
+	/**
+	* Run agent_end hook.
+	* Reconstructed from CLI subprocess exit data. Observe-only.
+	* Runs in parallel (fire-and-forget).
+	*/
+	async function runAgentEnd(event, ctx) {
+		return runVoidHook("agent_end", event, ctx);
+	}
+	/**
+	* Check if any hooks are registered for a given hook name.
+	*/
+	function hasHooks(hookName) {
+		return registry.typedHooks.some((h) => h.hookName === hookName);
+	}
+	/**
+	* Get count of registered hooks for a given hook name.
+	*/
+	function getHookCount(hookName) {
+		return registry.typedHooks.filter((h) => h.hookName === hookName).length;
+	}
+	return {
+		runBeforeReset,
+		runMessageReceived,
+		runMessageSending,
+		runMessageSent,
+		runBeforeToolCall,
+		runAfterToolCall,
+		runBeforeMessageWrite,
+		runSessionStart,
+		runSessionEnd,
+		runSubagentSpawning,
+		runSubagentDeliveryTarget,
+		runSubagentSpawned,
+		runSubagentEnded,
+		runGatewayStart,
+		runGatewayStop,
+		runBeforeRuntimeSpawn,
+		runAfterRuntimeExit,
+		runSessionResumed,
+		runAgentEnd,
+		hasHooks,
+		getHookCount
+	};
+}
+
+//#endregion
+//#region src/plugins/hook-runner-global.ts
+/**
+* Global Plugin Hook Runner
+*
+* Singleton hook runner that's initialized when plugins are loaded
+* and can be called from anywhere in the codebase.
+*/
+const log = createSubsystemLogger("plugins");
+let globalHookRunner = null;
+let globalRegistry = null;
+/**
+* Initialize the global hook runner with a plugin registry.
+* Called once when plugins are loaded during gateway startup.
+*/
+function initializeGlobalHookRunner(registry) {
+	globalRegistry = registry;
+	globalHookRunner = createHookRunner(registry, {
+		logger: {
+			debug: (msg) => log.debug(msg),
+			warn: (msg) => log.warn(msg),
+			error: (msg) => log.error(msg)
+		},
+		catchErrors: true
+	});
+	const hookCount = registry.hooks.length;
+	if (hookCount > 0) log.info(`hook runner initialized with ${hookCount} registered hooks`);
+}
+/**
+* Get the global hook runner.
+* Returns null if plugins haven't been loaded yet.
+*/
+function getGlobalHookRunner() {
+	return globalHookRunner;
+}
+async function runGlobalGatewayStopSafely(params) {
+	const hookRunner = getGlobalHookRunner();
+	if (!hookRunner?.hasHooks("gateway_stop")) return;
+	try {
+		await hookRunner.runGatewayStop(params.event, params.ctx);
+	} catch (err) {
+		if (params.onError) {
+			params.onError(err);
+			return;
+		}
+		log.warn(`gateway_stop hook failed: ${String(err)}`);
+	}
+}
+
+//#endregion
+export { applyReplyThreading as a, isRenderablePayload as c, createReplyToModeFilterForChannel as d, resolveReplyToMode as f, normalizeTargetForProvider as h, applyReplyTagsToPayload as i, shouldSuppressMessagingToolReplies as l, normalizeChannelTargetInput as m, initializeGlobalHookRunner as n, filterMessagingToolDuplicates as o, buildTargetResolverSignature as p, runGlobalGatewayStopSafely as r, filterMessagingToolMediaDuplicates as s, getGlobalHookRunner as t, shouldSuppressReasoningPayload as u };