@agentconnect.md/daemon 1.0.0-rc.248 → 1.0.0-rc.249

package/dist/{run-foreground-K9FNooBp.js → run-foreground-CN7_7yMq.js}

@@ -3,9 +3,9 @@ import { n as require_ms, t as require_src$3 } from "./src-DDtlVutj.js";
 import { n as init_esm_shims, t as __dirname } from "./esm-shims-DxGcm4Hw.js";
 import { t as DAEMON_VERSION } from "./version-DGaRXjBK.js";
 import { C as _coercedNumber, T as NEVER, a as array, d as literal, f as looseObject, i as any, m as object, o as boolean, p as number$1, t as ZodNumber, v as string, x as url$4 } from "./schemas-CQkO9hC5.js";
-import { _ as decodeEnvelope, a as agentChildEnv, c as persistRelays, d as normalizeGitUrl, f as RELAY_DAEMON_SUBPROTOCOL, g as buildEnvelope, h as decodeRelayDaemonFrame, i as selectAgent, m as buildRelayDaemonFrame, n as findAgentFiles, o as loadConfig, p as RELAY_DAEMON_WS_PATH, r as loadAgents, s as persistDaemonId, v as encode, x as RESERVED_MCP_SERVER_NAME, y as MAX_FRAME_BYTES } from "./load-agents-NvLpcg5H.js";
+import { _ as decodeEnvelope, a as agentChildEnv, c as persistRelays, d as normalizeGitUrl, f as RELAY_DAEMON_SUBPROTOCOL, g as buildEnvelope, h as decodeRelayDaemonFrame, i as selectAgent, m as buildRelayDaemonFrame, n as findAgentFiles, o as loadConfig, p as RELAY_DAEMON_WS_PATH, r as loadAgents, s as persistDaemonId, v as encode, x as RESERVED_MCP_SERVER_NAME, y as MAX_FRAME_BYTES } from "./load-agents-DspcHKeP.js";
 import { l as resolveRoot, o as mcpSocketPath, u as statePath } from "./paths-DEcUO8lC.js";
-import { S as resolveRuntimes, _ as writeMemoryFile, a as initGitInjection, b as cachedRuntimeNames, c as simpleGit, d as memoryProviderFor, f as MemoryConflictError, g as resolveInMemoryDir, h as listMemory, i as prepareWorkspace, l as createMemoryProvider, m as MemoryTooLargeError, n as installedRuntimes, o as probeGitVersion, p as MemoryPathError, r as prefetchWorkspace, s as sessionGitEnv, t as AcpHost, u as memoryKindOf, v as MEMORY_TOOL_NAMES, x as cachedRuntimeVersions, y as toolsForIntegrations } from "./acp-host-CUct-2CR.js";
+import { S as resolveRuntimes, _ as writeMemoryFile, a as initGitInjection, b as cachedRuntimeNames, c as simpleGit, d as memoryProviderFor, f as MemoryConflictError, g as resolveInMemoryDir, h as listMemory, i as prepareWorkspace, l as createMemoryProvider, m as MemoryTooLargeError, n as installedRuntimes, o as probeGitVersion, p as MemoryPathError, r as prefetchWorkspace, s as sessionGitEnv, t as AcpHost, u as memoryKindOf, v as MEMORY_TOOL_NAMES, x as cachedRuntimeVersions, y as toolsForIntegrations } from "./acp-host-hnOn2UR9.js";
 import { i as GitCredentialCache, n as gitcredSocketPath, r as writeGitcredShim, t as GitCredServer } from "./gitcred-server-Dcsq6QJe.js";
 import { B as ToolListChangedNotificationSchema, D as ListPromptsResultSchema, E as ListChangedOptionsBaseSchema, F as PromptListChangedNotificationSchema, G as isZ4Schema, H as isJSONRPCRequest, I as ReadResourceResultSchema, J as encodeFrame, K as safeParse, L as ResourceListChangedNotificationSchema, M as ListToolsResultSchema, O as ListResourceTemplatesResultSchema, P as McpError, R as SUPPORTED_PROTOCOL_VERSIONS, S as InitializeResultSchema, T as LATEST_PROTOCOL_VERSION, U as isJSONRPCResultResponse, V as isInitializedNotification, W as getObjectShape, _ as ElicitResultSchema, a as AjvJsonSchemaValidator, b as GetPromptResultSchema, c as mergeCapabilities, d as CompleteResultSchema, f as CreateMessageRequestSchema, g as ElicitRequestSchema, h as CreateTaskResultSchema, i as assertToolsCallTaskCapability, k as ListResourcesResultSchema, m as CreateMessageResultWithToolsSchema, n as serializeMessage, o as require_fast_deep_equal, p as CreateMessageResultSchema, q as decodeFrames, r as assertClientRequestTaskCapability, s as Protocol, t as ReadBuffer, u as CallToolResultSchema, v as EmptyResultSchema, w as JSONRPCMessageSchema, y as ErrorCode } from "./stdio-DnS8WcXi.js";
 import { URL as URL$1 } from "url";
@@ -4385,6 +4385,17 @@ var CpClient = class {
 		if (this.state !== "READY" && this.state !== "DRAINING") return;
 		this.transport?.send(encode(buildEnvelope("cron/report", report)));
 	}
+	/**
+	* Report a hook fire's turn outcome (D→C `hook/report` EVT, fire-and-forget) —
+	* the completion half of the HookRun two-stage lifecycle (the relay's
+	* `rc/run-report` opened the row). A drop is absorbed by the CP's
+	* HookRunReaper (`failed(orphaned)`, still overwritable by a late report).
+	* No-op unless READY/DRAINING.
+	*/
+	emitHookReport(report) {
+		if (this.state !== "READY" && this.state !== "DRAINING") return;
+		this.transport?.send(encode(buildEnvelope("hook/report", report)));
+	}
 	request(type, payload) {
 		const frame = buildEnvelope(type, payload);
 		return this.correlator.request(frame, (e) => this.transport.send(e));
@@ -196518,7 +196529,7 @@ function buildSyntheticMessage(agentId, cron, traceId) {
 			msgId: `cron:${cron.id}:${traceId}`,
 			traceId,
 			source: "cron",
-			platform: "slack",
+			platform: cron.target?.platform ?? "slack",
 			channel: cron.target?.channel ?? `cron:${cron.id}`,
 			thread: `cron:${cron.id}:${traceId}`,
 			sender: {
@@ -196577,6 +196588,121 @@ var Scheduler = class {
 	}
 };
 //#endregion
+//#region src/messages/hook-message.ts
+/** channel/thread from the affinity key — see the sessionKey grammar on {@link RdMsgHook}. */
+function splitSessionKey(msg) {
+	if (msg.sessionKey === msg.hookId) return { channel: msg.hookId };
+	if (msg.sessionKey === `${msg.hookId}:${msg.deliveryKey}`) return {
+		channel: msg.hookId,
+		thread: msg.deliveryKey
+	};
+	const hash = msg.sessionKey.lastIndexOf("#");
+	if (hash > 0) return {
+		channel: msg.sessionKey.slice(0, hash),
+		thread: msg.sessionKey.slice(hash + 1)
+	};
+	return { channel: msg.sessionKey };
+}
+/** The well-known payload fields a caller can speak through, in priority order. */
+const MESSAGE_FIELDS = [
+	"prompt",
+	"text",
+	"message"
+];
+/**
+* Pull the caller's message out of the delivery body: a bare JSON string is
+* the message itself; a JSON object speaks through its first `prompt`/`text`/
+* `message` string field (remaining fields become a context appendix); any
+* other shape (or non-JSON — can't happen via the relay's json-only ingress,
+* but stay tolerant) is presented whole as the payload.
+*/
+function deliveryMessage(body) {
+	try {
+		const parsed = JSON.parse(body);
+		if (typeof parsed === "string" && parsed.trim()) return { message: parsed };
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+			const obj = parsed;
+			for (const field of MESSAGE_FIELDS) {
+				const v = obj[field];
+				if (typeof v === "string" && v.trim()) {
+					const rest = Object.fromEntries(Object.entries(obj).filter(([k]) => k !== field));
+					return Object.keys(rest).length ? {
+						message: v,
+						rest: JSON.stringify(rest, null, 2)
+					} : { message: v };
+				}
+			}
+		}
+	} catch {}
+	return {
+		message: "",
+		rest: body
+	};
+}
+/** The turn text: the caller's payload-borne message (+ leftover fields as context). */
+function buildHookText(msg) {
+	const parts = [];
+	const body = msg.context?.body;
+	if (body) {
+		const { message, rest } = deliveryMessage(body);
+		if (message) parts.push(message);
+		if (rest) {
+			const label = msg.context?.truncated ? "Delivery payload (truncated):" : message ? "Rest of the delivery payload:" : "Delivery payload:";
+			parts.push([
+				label,
+				"```json",
+				rest,
+				"```"
+			].join("\n"));
+		}
+	}
+	return parts.length ? parts.join("\n\n") : `Webhook delivery ${msg.deliveryKey} arrived with an empty body.`;
+}
+/** A short anchor line for target-channel fires: the caller's message when one
+*  is extractable (first line, capped), else the delivery key. */
+function hookAnchorText(msg) {
+	const body = msg.context?.body;
+	const line = (body ? deliveryMessage(body).message : "").split("\n", 1)[0].trim();
+	return `🪝 ${(line.length > 140 ? `${line.slice(0, 139)}…` : line) || `Webhook delivery ${msg.deliveryKey}`}`;
+}
+function buildHookMessage(msg, traceId) {
+	const { channel, thread } = splitSessionKey(msg);
+	const target = msg.target;
+	if (target) return {
+		msgId: msg.msgId,
+		traceId,
+		source: "hook",
+		platform: target.platform,
+		channel: target.channel,
+		thread: msg.msgId,
+		sender: {
+			id: `hook:${msg.hookId}`,
+			isBot: false
+		},
+		text: buildHookText(msg),
+		mentionedBots: [],
+		isDm: false,
+		trigger: "hook"
+	};
+	return {
+		msgId: msg.msgId,
+		traceId,
+		source: "hook",
+		platform: "hook",
+		channel,
+		...thread ? { thread } : {},
+		sender: {
+			id: `hook:${msg.hookId}`,
+			isBot: false
+		},
+		text: buildHookText(msg),
+		mentionedBots: [],
+		isDm: false,
+		trigger: "hook",
+		headless: true
+	};
+}
+//#endregion
 //#region src/runtimes/runtime-prober.ts
 const DEFAULT_TIMEOUT_MS = 3e4;
 const DEFAULT_CONCURRENCY = 3;
@@ -196797,9 +196923,11 @@ var RelayClient = class {
 		}
 		this.deps.log.debug(`relay(${this.relayId}): ignoring ${frame.type}`);
 	}
-	/** An inbound webchat op: dispatch it, reply `rd/ack`, and let the daemon stream `rd/chat`. */
+	/** An inbound rd/msg: dispatch it, reply `rd/ack`; a webchat op additionally
+	*  streams `rd/chat` back over this socket (hooks have no reply stream). */
 	handleMsg(reqId, msg) {
-		const ack = this.deps.onRelayMsg(msg, (event) => this.sendChat(msg.chatId, event));
+		const chat = msg.source === "webchat" ? (event) => this.sendChat(msg.chatId, event) : () => void 0;
+		const ack = this.deps.onRelayMsg(msg, chat);
 		this.transport?.send(JSON.stringify(buildRelayDaemonFrame("rd/ack", ack, { corr: reqId })));
 	}
 	/** Send one reply chunk back over THIS relay's socket, stamping the per-chat `seq`. */
@@ -214408,14 +214536,16 @@ var Daemon = class Daemon {
 	}
 	relayMsgAcks = /* @__PURE__ */ new Map();
 	/**
-	* Dispatch one inbound relay webchat op (`rd/msg`) and return the `rd/ack` verdict —
-	* the relay-path entry, reusing the SAME turn engine + by-key cores as the (retiring)
-	* CP path. The `chat` callback streams the reply back as `rd/chat` over the relay
-	* socket the op arrived on (wrapped into the sink).
+	* Dispatch one inbound relay item (`rd/msg` — a webchat op or a hook fire) and
+	* return the `rd/ack` verdict — the relay-path entry, reusing the SAME turn
+	* engine + by-key cores as the (retiring) CP path. The `chat` callback streams
+	* a webchat reply back as `rd/chat` over the relay socket the op arrived on
+	* (no-op for hooks — their outcome goes to the CP as `hook/report`).
 	*
 	* Deduped by the relay-minted (sessionKey, msgId): the wire is at-least-once, so a
 	* retransmitted rd/msg (identical msgId) must NOT run the user's turn a second time —
-	* replay the original ack (so the relay settles) without re-dispatching.
+	* replay the original ack (so the relay settles) without re-dispatching. For hooks
+	* the same replay absorbs a GitHub/manual REDELIVERY of the same deliveryKey.
 	*/
 	handleRelayMsg(msg, chat) {
 		const dedupKey = `${msg.sessionKey}:${msg.msgId}`;
@@ -214424,11 +214554,79 @@ var Daemon = class Daemon {
 			this.log.debug(`relay: duplicate rd/msg ${dedupKey} — replaying ack (no re-dispatch)`);
 			return prior;
 		}
-		const ack = this.dispatchRelayOp(msg, chat);
+		const ack = msg.source === "hook" ? this.dispatchRelayHook(msg) : this.dispatchRelayOp(msg, chat);
 		if (this.relayMsgAcks.size >= 2e3) this.relayMsgAcks.clear();
 		this.relayMsgAcks.set(dedupKey, ack);
 		return ack;
 	}
+	/**
+	* Ack-verdict gate for one hook fire (`rd/msg` hook member) — the mirror of
+	* {@link dispatchWebchatTurn}'s synchronous gates: the relay's rc/run-report
+	* needs a REASONED rejection now, not a silently dropped fire-and-forget
+	* dispatch. Accepted fires run async via {@link onHookFire}.
+	*/
+	dispatchRelayHook(msg) {
+		if (!this.agents.has(msg.agentId)) {
+			this.log.warn(`hook: no agent "${msg.agentId}" on this daemon — rejecting fire ${msg.msgId}`);
+			return {
+				msgId: msg.msgId,
+				accepted: false,
+				reason: "no_agent"
+			};
+		}
+		if (this.agents.get(msg.agentId)?.pause) {
+			this.log.info(`hook: agent "${msg.agentId}" is paused — rejecting fire ${msg.msgId}`);
+			return {
+				msgId: msg.msgId,
+				accepted: false,
+				reason: "paused"
+			};
+		}
+		if (this.draining || this.drainingAgents.has(msg.agentId)) {
+			this.log.info(`hook: agent "${msg.agentId}" is draining — rejecting fire ${msg.msgId}`);
+			return {
+				msgId: msg.msgId,
+				accepted: false,
+				reason: "draining"
+			};
+		}
+		this.onHookFire(msg).catch((err) => this.log.error(`hook fire dispatch failed for agent "${msg.agentId}": ${formatErr(err)}`));
+		return {
+			msgId: msg.msgId,
+			accepted: true
+		};
+	}
+	/**
+	* A hook fired for `agentId` (explicit target — no routing;
+	* webhook-triggers-and-github-events.md). The relay already opened the HookRun
+	* row (`rc/run-report accepted`); when the turn ends this closes it with a
+	* completion `hook/report` EVT on the control WS (the cron/report pattern).
+	* Anchoring rides the shared {@link fireTrigger} path: with a target the
+	* trigger text lands in the channel and the session threads under it,
+	* without one the fire runs headless.
+	*/
+	async onHookFire(msg) {
+		const firedAt = this.clock.now();
+		const report = (status, extra = {}) => {
+			this.cpClient?.emitHookReport({
+				hookId: msg.hookId,
+				agentId: msg.agentId,
+				deliveryKey: msg.deliveryKey,
+				status,
+				durationMs: Math.max(0, this.clock.now() - firedAt),
+				...extra
+			});
+		};
+		const nmsg = buildHookMessage(msg, randomUUID());
+		try {
+			const sessionId = await this.fireTrigger(msg.agentId, nmsg, msg.target, hookAnchorText(msg), `hook "${msg.hookId}"`);
+			if (sessionId !== null) report("success", { sessionId });
+			else report("failed", { reason: "dropped" });
+		} catch (err) {
+			report("failed", { reason: err.message?.slice(0, 300) || "dispatch failed" });
+			throw err;
+		}
+	}
 	/** The op-switch behind {@link handleRelayMsg} (dedup handled by the caller). */
 	dispatchRelayOp(msg, chat) {
 		const sink = {
@@ -215938,37 +216136,46 @@ var Daemon = class Daemon {
 		}
 	}
 	/**
-	* A cron fired for `agentId` (§8.6 bypass — the cron names its agent; no
-	* routing). The fire is stamped into D11 first (the daemon owns last-run,
-	* protocol §5.4). With a target channel, the trigger text is posted there as a
-	* real ANCHOR message and the session threads its replies under it —
-	* equivalent to a user posting the trigger in-channel. Without one (or when
-	* the anchor can't be posted) the turn still runs; a `headless` fire
-	* additionally suppresses all platform output in dispatch.
+	* Shared fire path for the non-message trigger sources (cron, hook — both
+	* name their agent; no routing). With a target channel, `anchorText` is
+	* posted there as a real ANCHOR message (through the target integration's
+	* platform connection — Slack/Telegram/Discord alike) and the session
+	* threads its replies under it — equivalent to a user posting the trigger
+	* in-channel. Without one (or when the anchor can't be posted) the turn
+	* still runs; a `headless` msg additionally suppresses all platform output
+	* in dispatch. Resolves with dispatch's sessionId (null = gate-dropped).
 	*/
-	async onCronFire(agentId, msg, cron) {
-		const firedAt = this.clock.now();
-		this.store.setCronLastRun(`${agentId}:${cron.id}`, firedAt);
-		if (cron.origin === "cp") this.cpClient?.emitCronReport({
-			cronId: cron.id,
-			agentId,
-			firedAt: new Date(firedAt).toISOString()
-		});
-		if (cron.target?.channel) {
-			const conn = this.replyConnFor(agentId, cron.target.integrationId);
-			if (!conn) this.log.warn(`cron "${cron.id}": agent "${agentId}" has no live slack connection — running without output`);
+	async fireTrigger(agentId, msg, target, anchorText, label) {
+		if (target?.channel) {
+			const conn = this.replyConnFor(agentId, target.integrationId);
+			if (!conn) this.log.warn(`${label}: agent "${agentId}" has no live platform connection — running without output`);
 			else try {
-				const ts = await conn.postMessage(cron.target.channel, `⏰ ${cron.trigger}`);
+				const ts = await conn.postMessage(target.channel, anchorText);
 				if (ts) msg = {
 					...msg,
 					thread: ts
 				};
 			} catch (err) {
-				this.log.warn(`cron "${cron.id}": failed to post trigger to ${cron.target.channel} (${formatErr(err)}) — running without anchor`);
+				this.log.warn(`${label}: failed to post trigger to ${target.channel} (${formatErr(err)}) — running without anchor`);
 			}
 		}
+		return this.dispatch(agentId, msg, target?.integrationId);
+	}
+	/**
+	* A cron fired for `agentId` (§8.6 bypass). The fire is stamped into D11
+	* first (the daemon owns last-run, protocol §5.4); the anchor+dispatch ride
+	* the shared {@link fireTrigger} path.
+	*/
+	async onCronFire(agentId, msg, cron) {
+		const firedAt = this.clock.now();
+		this.store.setCronLastRun(`${agentId}:${cron.id}`, firedAt);
+		if (cron.origin === "cp") this.cpClient?.emitCronReport({
+			cronId: cron.id,
+			agentId,
+			firedAt: new Date(firedAt).toISOString()
+		});
 		try {
-			const sessionId = await this.dispatch(agentId, msg, cron.target?.integrationId);
+			const sessionId = await this.fireTrigger(agentId, msg, cron.target, `⏰ ${cron.trigger}`, `cron "${cron.id}"`);
 			if (cron.origin === "cp" && sessionId !== null) this.cpClient?.emitCronReport({
 				cronId: cron.id,
 				agentId,
@@ -216230,4 +216437,4 @@ async function runForeground(opts, deps = {}) {
 //#endregion
 export { ClientTransport as i, CP_SUBPROTOCOL as n, CP_WS_PATH as r, runForeground as t };
 
-//# sourceMappingURL=run-foreground-K9FNooBp.js.map
+//# sourceMappingURL=run-foreground-CN7_7yMq.js.map