@bastani/atomic 0.9.19-alpha.1 → 0.9.19-alpha.11

package/dist/builtin/intercom/broker/send-handler.ts

@@ -1,3 +1,4 @@
+import { TERMINAL_CHILD_ASK_REFUSAL } from "../recipient-purpose.js";
 import type net from "node:net";
 import type { BrokerMessage, Message, SessionInfo } from "../types.js";
 import {
@@ -14,6 +15,7 @@ import { SupervisorChannelCache } from "./supervisor-channel.js";
 import { isVerticalBypass, sameGroup } from "./group-isolation.js";
 import { sessionGroups, sessionsShareGroup } from "./group-membership.js";
 import { PendingQuestionIndex } from "./pending-question-index.js";
+import { isAgentRecipient, NON_AGENT_RECIPIENT_REFUSAL } from "../recipient-purpose.js";
 
 export interface BrokerConnectedSession {
   socket: net.Socket;
@@ -57,6 +59,7 @@ export interface PendingStageRoute {
   readonly attemptId?: string;
 	readonly liveTargetId?: string;
 	readonly signature?: string;
+	readonly resolveReplyTarget?: true;
 }
 
 export type PendingStageRouter = (route: PendingStageRoute) => boolean;
@@ -111,6 +114,7 @@ export function handleBrokerSend(
 	canControlLiveWorkflowStage?: LiveWorkflowStageController,
 	resolveLegacyWorkflowStageTarget?: LegacyWorkflowStageTargetResolver,
 	writeConfirmed?: ConfirmedMessageWriter,
+	isNonAgentWorkflowTarget?: (target: string) => boolean,
 ): void {
   const message = clientMessage.message;
   const messageId = wireMessageId(message);
@@ -139,6 +143,12 @@ export function handleBrokerSend(
     return;
   }
   const requirePendingReply = clientMessage.requirePendingReply === true;
+  const hasExpectedRecipientId = Object.prototype.hasOwnProperty.call(clientMessage, "expectedRecipientId");
+  if (hasExpectedRecipientId && (typeof clientMessage.expectedRecipientId !== "string" || !clientMessage.expectedRecipientId.trim())) {
+    write(socket, { type: "delivery_failed", messageId, attemptId, reason: "Invalid expectedRecipientId format" });
+    return;
+  }
+  const expectedRecipientId = hasExpectedRecipientId ? clientMessage.expectedRecipientId as string : undefined;
   if (Object.prototype.hasOwnProperty.call(clientMessage, "channel")) {
     write(socket, { type: "delivery_failed", messageId: message.id, attemptId, reason: "Invalid channel" });
     return;
@@ -148,6 +158,10 @@ export function handleBrokerSend(
     write(socket, { type: "delivery_failed", messageId, attemptId, reason: "Invalid requirePendingReply message" });
     return;
   }
+  if (expectedRecipientId !== undefined && (supervisorSend || message.replyTo === undefined || message.expectsReply === true)) {
+    write(socket, { type: "delivery_failed", messageId, attemptId, reason: "Invalid expectedRecipientId message" });
+    return;
+  }
 
 
   const fromSession = currentId ? sessions.get(currentId) : undefined;
@@ -157,7 +171,8 @@ export function handleBrokerSend(
   }
 	const senderIdentity = fromSession.registrationReturnAddress ?? fromSession.info.id;
 	const logicalTarget = typeof clientMessage.logicalTarget === "string" ? clientMessage.logicalTarget : clientMessage.to;
-	const baseSignature = buildMessageSendSignature(logicalTarget, message, senderIdentity);
+	const messageSignature = buildMessageSendSignature(logicalTarget, message, senderIdentity);
+	const baseSignature = expectedRecipientId === undefined ? messageSignature : JSON.stringify({ expectedRecipientId, messageSignature });
 	const signature = requirePendingReply
 		? JSON.stringify({
 				requirePendingReply: true,
@@ -175,6 +190,10 @@ export function handleBrokerSend(
     return;
   }
 	const workflowTarget = parseWorkflowStageTarget(trimmedTo);
+	if (isNonAgentWorkflowTarget?.(trimmedTo)) {
+		write(socket, { type: "delivery_failed", messageId: message.id, attemptId, reason: NON_AGENT_RECIPIENT_REFUSAL });
+		return;
+	}
 	// Slice 3 (D3): asks to pattern/future stage targets stay refused; `send` is queued
 	// sticky by the workflow host, so the refusal must happen before any live delivery.
 	if (workflowTarget !== undefined && workflowTarget.kind !== "path" && message.expectsReply === true) {
@@ -206,14 +225,19 @@ export function handleBrokerSend(
 	const liveWorkflowTarget = sessions.has(trimmedTo) ? undefined : resolveLiveWorkflowStage?.(trimmedTo);
 	const exactIdTarget = sessions.get(trimmedTo) ?? liveWorkflowTarget;
   const reachableAcrossGroups = supervisorSend || Boolean(message.replyTo);
-  const candidates = reachableAcrossGroups
-    ? Array.from(sessions.values(), (session) => session.info)
-    : Array.from(sessions.values(), (session) => session.info).filter(
-        (info) => sessionsShareGroup(info, fromSession.info),
-      );
+  const visibleCandidates = Array.from(sessions.values(), (session) => session.info).filter(
+	(info) => reachableAcrossGroups || sessionsShareGroup(info, fromSession.info),
+  );
+  const candidates = visibleCandidates.filter(isAgentRecipient);
   const resolution = exactIdTarget
     ? ({ kind: "resolved", session: exactIdTarget.info } as const)
     : resolveSessionTarget(candidates, trimmedTo);
+  if (expectedRecipientId !== undefined && (resolution.kind !== "resolved" || resolution.session.id !== expectedRecipientId)) {
+    write(socket, { type: "delivery_failed", messageId, attemptId,
+      reason: resolution.kind === "resolved" ? "Reply target does not match the expected recipient" : sessionTargetFailureReason(clientMessage.to, resolution),
+    });
+    return;
+  }
   if (resolution.kind === "resolved") {
     const target = sessions.get(resolution.session.id);
     if (!target) {
@@ -226,6 +250,10 @@ export function handleBrokerSend(
       });
       return;
     }
+	if (!isAgentRecipient(target.info)) {
+		write(socket, { type: "delivery_failed", messageId: message.id, attemptId, reason: NON_AGENT_RECIPIENT_REFUSAL });
+		return;
+	}
     if (target.info.id === fromSession.info.id) {
       write(socket, { type: "delivery_failed", messageId: message.id, attemptId, reason: "Cannot message the current session" });
       return;
@@ -295,6 +323,10 @@ export function handleBrokerSend(
       });
       return;
     }
+  if (message.expectsReply === true && target.info.replyCapability === "terminal") {
+    write(socket, { type: "delivery_failed", messageId: message.id, attemptId, reason: TERMINAL_CHILD_ASK_REFUSAL });
+    return;
+  }
 	if (deliveredMatch === "match") {
 		if (message.expectsReply === true) {
 			const acceptedQuestionTarget = deliveredMessages.lookupQuestionTarget(
@@ -312,6 +344,8 @@ export function handleBrokerSend(
 				return;
 			}
 			pendingQuestions.record(fromSession.info.id, target.info.id, message.id);
+			if (clientMessage.resolveReplyTarget === true && attemptId !== undefined)
+				write(socket, { type: "question_target", messageId: message.id, attemptId, sessionId: target.info.id });
 		}
 		write(socket, { type: "delivered", messageId: message.id, attemptId });
 		return;
@@ -355,6 +389,7 @@ export function handleBrokerSend(
 				...(attemptId ? { attemptId } : {}),
 				liveTargetId: target.info.id,
 				signature,
+				...(clientMessage.resolveReplyTarget === true ? { resolveReplyTarget: true } : {}),
 			})
 		) {
 			return;
@@ -402,6 +437,8 @@ export function handleBrokerSend(
 			return;
 		}
 		if (message.expectsReply === true) pendingQuestions.record(fromSession.info.id, target.info.id, message.id);
+		if (message.expectsReply === true && clientMessage.resolveReplyTarget === true && attemptId !== undefined)
+			write(socket, { type: "question_target", messageId: message.id, attemptId, sessionId: target.info.id });
 		write(socket, { type: "delivered", messageId: message.id, attemptId });
 		return;
 	}
@@ -419,6 +456,8 @@ export function handleBrokerSend(
 		});
 		return;
 	}
+	if (message.expectsReply === true && clientMessage.resolveReplyTarget === true && attemptId !== undefined)
+		write(socket, { type: "question_target", messageId: message.id, attemptId, sessionId: target.info.id });
     const finishDelivery = (): void => {
 	  let accepted: ReturnType<DeliveredMessageCache["accept"]>;
 	  try {
@@ -442,6 +481,17 @@ export function handleBrokerSend(
 		});
 		return;
 	  }
+      // A terminal presence frame can arrive while the socket write callback is pending.
+      // Retain accepted-delivery authority, but never open a reply route after termination.
+      if (message.expectsReply === true && target.info.replyCapability === "terminal") {
+        write(socket, { type: "delivery_failed", messageId: message.id, attemptId, reason: TERMINAL_CHILD_ASK_REFUSAL });
+        return;
+      }
+      if (message.expectsReply === true && sessions.get(target.info.id) !== target) {
+        write(socket, { type: "delivery_failed", messageId: message.id, attemptId,
+          reason: `Session "${target.info.name ?? target.info.id}" disconnected before replying` });
+        return;
+      }
       if (message.expectsReply === true) {
         pendingQuestions.record(fromSession.info.id, target.info.id, message.id);
 	  }
@@ -467,6 +517,10 @@ export function handleBrokerSend(
     finishDelivery();
     return;
   }
+	if (resolution.kind === "not_found" && visibleCandidates.some((info) => !isAgentRecipient(info) && info.name?.toLowerCase() === trimmedTo.toLowerCase())) {
+		write(socket, { type: "delivery_failed", messageId: message.id, attemptId, reason: NON_AGENT_RECIPIENT_REFUSAL });
+		return;
+	}
 	if (
 		resolution.kind === "not_found" &&
 		!supervisorSend &&
@@ -479,6 +533,7 @@ export function handleBrokerSend(
 			message,
 			...(attemptId ? { attemptId } : {}),
 			signature,
+			...(clientMessage.resolveReplyTarget === true ? { resolveReplyTarget: true } : {}),
 		})
 	) {
 		return;

package/dist/builtin/intercom/broker/terminal-questions.ts

@@ -0,0 +1,29 @@
+import type net from "node:net";
+import { TERMINAL_CHILD_ASK_REFUSAL } from "../recipient-purpose.js";
+import type { BrokerMessage } from "../types.js";
+import type { PendingQuestionIndex } from "./pending-question-index.js";
+import type { BrokerConnectedSession } from "./send-handler.js";
+
+/** Settle only questions already admitted to this exact execution's registration. */
+export function failTerminalQuestions(
+  target: BrokerConnectedSession,
+  sessions: Map<string, BrokerConnectedSession>,
+  pending: PendingQuestionIndex,
+  write: (socket: net.Socket, message: BrokerMessage) => void,
+): void {
+  for (const question of pending.takeForTarget(target.info.id)) {
+    const sender = sessions.get(question.senderSessionId);
+    if (!sender) continue;
+    write(sender.socket, {
+      type: "message",
+      from: target.info,
+      message: {
+        id: `terminal:${question.messageId}`,
+        timestamp: Date.now(),
+        replyTo: question.messageId,
+        replyError: TERMINAL_CHILD_ASK_REFUSAL,
+        content: { text: TERMINAL_CHILD_ASK_REFUSAL },
+      },
+    });
+  }
+}