@@ -2,6 +2,7 @@ import type { RequestProgressSink } from '@agent-device/contracts/progress';
22import net from 'node:net' ;
33import { AppError } from '@agent-device/kernel/errors' ;
44import { loadNodeHttpRequester , readNodeHttpResponseBody } from '@agent-device/host-kit/transport' ;
5+ import { abortedRequestError , refuseAbortedRequest } from '@agent-device/host-kit/request' ;
56import type { DaemonRequest , DaemonResponse } from '../daemon/daemon-request.ts' ;
67import { emitDiagnostic } from '@agent-device/host-kit/diagnostics' ;
78import type { DaemonPaths , DaemonTransportPreference } from '../daemon-resolution.ts' ;
@@ -26,6 +27,13 @@ import { readVersion } from '@agent-device/host-kit/version';
2627type ResolvedDaemonTransport = 'socket' | 'http' ;
2728type SendRequestOptions = {
2829 onProgress ?: RequestProgressSink ;
30+ /**
31+ * The caller's per-request cancellation (#3178). Aborted at or before a send attempt, nothing
32+ * leaves on that attempt; aborted in flight, the attempt's own connection is destroyed — which is
33+ * what makes the daemon mark the request canceled — and the promise rejects with the typed
34+ * canceled-request error. An abort is never a timeout: it never reaches `handleRequestTimeout`.
35+ */
36+ signal ?: AbortSignal ;
2937} ;
3038
3139const LOCAL_DAEMON_HEALTHCHECK_TIMEOUT_MS = 500 ;
@@ -240,6 +248,9 @@ export async function sendRequest(
240248) : Promise < DaemonResponse > {
241249 const transport = chooseTransport ( info , preference ) ;
242250 const deadline = typeof timeoutMs === 'number' ? performance . now ( ) + timeoutMs : undefined ;
251+ // A canceled caller must not open a connection just to lose it, and a fallback or instance retry
252+ // that begins after the abort must not send either — every attempt starts behind this check.
253+ refuseAbortedRequest ( options . signal , req . meta ?. requestId ) ;
243254 try {
244255 return await sendRequestWithTransport ( info , req , statePaths , timeoutMs , transport , options ) ;
245256 } catch ( error ) {
@@ -452,17 +463,26 @@ async function sendSocketRequest(
452463) : Promise < DaemonResponse > {
453464 const port = info . port ;
454465 if ( ! port ) throw daemonEndpointUnavailableError ( 'socket' ) ;
466+ const callerSignal = options . signal ;
467+ refuseAbortedRequest ( callerSignal , req . meta ?. requestId ) ;
455468 return new Promise ( ( resolve , reject ) => {
456469 let requestWritten = false ;
470+ let settled = false ;
457471 const socket = net . createConnection ( { host : '127.0.0.1' , port } , ( ) => {
472+ // An abort that landed while the connection was still opening must not write the request.
473+ if ( callerSignal ?. aborted ) {
474+ settled = true ;
475+ rejectAborted ( callerSignal ) ;
476+ return ;
477+ }
458478 requestWritten = true ;
459479 socket . write ( `${ JSON . stringify ( req ) } \n` ) ;
460480 } ) ;
461- let settled = false ;
462481 const timeoutHandle =
463482 typeof timeoutMs === 'number'
464483 ? setTimeout ( ( ) => {
465484 settled = true ;
485+ detachCallerAbort ( ) ;
466486 socket . destroy ( ) ;
467487 reject (
468488 handleRequestTimeout ( {
@@ -473,6 +493,27 @@ async function sendSocketRequest(
473493 ) ;
474494 } , timeoutMs )
475495 : undefined ;
496+ // Destroying the connection is what makes the daemon mark the request canceled; the rejection
497+ // keeps the typed canceled-request error, never a socket-error or timeout shape. The timeout
498+ // timer is cleared here because an abort is never a timeout: nothing may run the timeout's
499+ // runner sweep or daemon reset after the caller canceled.
500+ const rejectAborted = ( signal : AbortSignal ) : void => {
501+ detachCallerAbort ( ) ;
502+ if ( timeoutHandle ) clearTimeout ( timeoutHandle ) ;
503+ socket . destroy ( ) ;
504+ reject ( abortedRequestError ( signal , requestWritten ? 'unknown' : 'no' , req . meta ?. requestId ) ) ;
505+ } ;
506+ const onCallerAbort = ( ) : void => {
507+ if ( settled ) return ;
508+ settled = true ;
509+ rejectAborted ( callerSignal ! ) ;
510+ } ;
511+ const detachCallerAbort = ( ) : void => {
512+ if ( callerSignal ) callerSignal . removeEventListener ( 'abort' , onCallerAbort ) ;
513+ } ;
514+ if ( callerSignal ) {
515+ callerSignal . addEventListener ( 'abort' , onCallerAbort , { once : true } ) ;
516+ }
476517
477518 readDaemonSocketProgressResponse ( socket , {
478519 req,
@@ -483,10 +524,12 @@ async function sendSocketRequest(
483524 } ,
484525 resolve : ( response ) => {
485526 settled = true ;
527+ detachCallerAbort ( ) ;
486528 resolve ( response ) ;
487529 } ,
488530 reject : ( error ) => {
489531 settled = true ;
532+ detachCallerAbort ( ) ;
490533 reject ( error ) ;
491534 } ,
492535 } ) ;
@@ -495,6 +538,7 @@ async function sendSocketRequest(
495538 if ( settled ) return ;
496539 settled = true ;
497540 if ( timeoutHandle ) clearTimeout ( timeoutHandle ) ;
541+ detachCallerAbort ( ) ;
498542 reject (
499543 handleTransportError ( err , req . meta ?. requestId , false , {
500544 daemonSocketRequestWritten : requestWritten ,
@@ -563,8 +607,27 @@ async function sendHttpRequest(
563607 Object . assign ( headers , buildRemoteInstancePreconditionHeaders ( info ) ) ;
564608 }
565609 const transport = await loadNodeHttpRequester ( rpcUrl . protocol ) ;
610+ const callerSignal = options . signal ;
611+ refuseAbortedRequest ( callerSignal , req . meta ?. requestId ) ;
566612
567613 return await new Promise ( ( resolve , reject ) => {
614+ let settled = false ;
615+ let requestEnded = false ;
616+ const detachCallerAbort = ( ) : void => {
617+ if ( callerSignal ) callerSignal . removeEventListener ( 'abort' , onCallerAbort ) ;
618+ } ;
619+ const resolveOnce = ( response : DaemonResponse | PromiseLike < DaemonResponse > ) : void => {
620+ if ( settled ) return ;
621+ settled = true ;
622+ detachCallerAbort ( ) ;
623+ resolve ( response ) ;
624+ } ;
625+ const rejectOnce = ( error : unknown ) : void => {
626+ if ( settled ) return ;
627+ settled = true ;
628+ detachCallerAbort ( ) ;
629+ reject ( error ) ;
630+ } ;
568631 const request = transport . request (
569632 {
570633 protocol : rpcUrl . protocol ,
@@ -578,7 +641,7 @@ async function sendHttpRequest(
578641 if ( isRemoteInstanceMismatchResponse ( res . statusCode , res . headers ?? { } ) ) {
579642 res . resume ( ) ;
580643 if ( timeoutHandle ) clearTimeout ( timeoutHandle ) ;
581- reject (
644+ rejectOnce (
582645 new AppError ( 'COMMAND_FAILED' , 'Remote daemon instance changed' , {
583646 reason : 'remote_instance_mismatch' ,
584647 daemonBaseUrl : info . baseUrl ,
@@ -590,7 +653,7 @@ async function sendHttpRequest(
590653 readDaemonHttpProgressResponse ( res , {
591654 req,
592655 onProgress : options . onProgress ,
593- reject,
656+ reject : rejectOnce ,
594657 clearTimeout : ( ) => {
595658 if ( timeoutHandle ) clearTimeout ( timeoutHandle ) ;
596659 } ,
@@ -599,8 +662,8 @@ async function sendHttpRequest(
599662 info,
600663 req,
601664 stateDir : statePaths . baseDir ,
602- resolve,
603- reject,
665+ resolve : resolveOnce ,
666+ reject : rejectOnce ,
604667 } ) ;
605668 } ,
606669 } ) ;
@@ -621,13 +684,13 @@ async function sendHttpRequest(
621684 info,
622685 req,
623686 stateDir : statePaths . baseDir ,
624- resolve,
625- reject,
687+ resolve : resolveOnce ,
688+ reject : rejectOnce ,
626689 } ) ;
627690 } )
628691 . catch ( ( error : unknown ) => {
629692 if ( timeoutHandle ) clearTimeout ( timeoutHandle ) ;
630- reject ( error ) ;
693+ rejectOnce ( error ) ;
631694 } ) ;
632695 } ,
633696 ) ;
@@ -637,7 +700,7 @@ async function sendHttpRequest(
637700 typeof timeoutMs === 'number'
638701 ? setTimeout ( ( ) => {
639702 request . destroy ( ) ;
640- reject (
703+ rejectOnce (
641704 handleRequestTimeout ( {
642705 info,
643706 statePaths,
@@ -647,13 +710,30 @@ async function sendHttpRequest(
647710 } , timeoutMs )
648711 : undefined ;
649712
713+ // Destroying the request closes this one connection, which is what makes the daemon mark the
714+ // request canceled. The timeout timer is cleared because an abort is never a timeout: nothing
715+ // may run the timeout's runner sweep or daemon reset after the caller canceled. The destroy
716+ // surfaces as a request `error`, which `settled` keeps out of the already-typed rejection.
717+ const onCallerAbort = ( ) : void => {
718+ if ( settled ) return ;
719+ if ( timeoutHandle ) clearTimeout ( timeoutHandle ) ;
720+ request . destroy ( ) ;
721+ rejectOnce (
722+ abortedRequestError ( callerSignal ! , requestEnded ? 'unknown' : 'no' , req . meta ?. requestId ) ,
723+ ) ;
724+ } ;
725+ if ( callerSignal ) {
726+ callerSignal . addEventListener ( 'abort' , onCallerAbort , { once : true } ) ;
727+ }
728+
650729 request . on ( 'error' , ( err ) => {
651730 if ( timeoutHandle ) clearTimeout ( timeoutHandle ) ;
652- reject ( handleTransportError ( err , req . meta ?. requestId , remote ) ) ;
731+ rejectOnce ( handleTransportError ( err , req . meta ?. requestId , remote ) ) ;
653732 } ) ;
654733
655734 request . write ( rpcPayload ) ;
656735 request . end ( ) ;
736+ requestEnded = true ;
657737 } ) ;
658738}
659739
0 commit comments