Skip to content

Commit 88a0846

Browse files
committed
feat(client): thread the per-call signal through the daemon client and both transports
Wire the declared signal from the client's execute seam down to the transport context and the request guard, and from the built-in transport into both daemon wires (#3178): - `sendToDaemon` refuses an already-aborted call before daemon startup and guards each client-side phase; an abort during the artifact upload now combines with the lease beat's own signal so the upload stops for either owner. - The socket transport destroys its connection on abort, and the HTTP transport destroys its request; either way the daemon sees a client disconnect and marks the request canceled. Every settle path detaches the abort listener, and the timeout timer is cleared on abort so an abort never triggers the timeout path's runner sweep or daemon reset. - Retries and fallback attempts start behind a refusal check, so nothing is sent after an abort.
1 parent df51767 commit 88a0846

4 files changed

Lines changed: 147 additions & 24 deletions

File tree

‎packages/host-kit/src/request.ts‎

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -9,4 +9,9 @@ export {
99
throwIfRequestCanceled,
1010
} from './internal/request-cancel.ts';
1111
export { emitRequestProgress, withRequestProgressSink } from './internal/request-progress.ts';
12-
export { createRequestGuard, type RequestGuard } from './internal/request-guard.ts';
12+
export {
13+
abortedRequestError,
14+
createRequestGuard,
15+
refuseAbortedRequest,
16+
type RequestGuard,
17+
} from './internal/request-guard.ts';

‎src/agent-device-client.ts‎

Lines changed: 14 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -74,6 +74,7 @@ import { isRecord, readSnapshotKeyboardBandFact } from '@agent-device/kernel/rec
7474
import { readResponseWarnings } from '@agent-device/kernel/success-text';
7575
import { createLeaseClient } from './client/lease-client.ts';
7676
import { normalizeScreenshotCaptureResult } from './client/screenshot-result.ts';
77+
import { createRequestGuard } from '@agent-device/host-kit/request';
7778

7879
export function createAgentDeviceClient(
7980
config: AgentDeviceClientConfig = {},
@@ -95,6 +96,11 @@ export function createAgentDeviceClient(
9596
input?: Record<string, unknown>,
9697
): Promise<Record<string, unknown>> => {
9798
const merged = mergeClientOptions(config, options);
99+
const cancellation = createRequestGuard({
100+
signal: merged.signal,
101+
requestId: merged.requestId,
102+
});
103+
cancellation.refuseIfAborted();
98104
const request = {
99105
session: resolveSessionName(merged.session),
100106
command,
@@ -104,7 +110,14 @@ export function createAgentDeviceClient(
104110
runtime: merged.runtime,
105111
meta: buildMeta(merged),
106112
};
107-
const response = await transport(request, { authToken: merged.daemonAuthToken });
113+
// `signal` rides the transport context (it is a live object, never wire data), and the guard
114+
// answers for a custom transport that ignores it: the caller's promise settles on abort either
115+
// way. The built-in transport closes the request's connection, which is what makes the daemon
116+
// mark the request canceled.
117+
const response = await cancellation.guard(
118+
async () =>
119+
await transport(request, { authToken: merged.daemonAuthToken, signal: merged.signal }),
120+
);
108121
if (!response.ok) {
109122
throwDaemonError(response.error);
110123
}

‎src/daemon-client/daemon-client-transport.ts‎

Lines changed: 90 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@ import type { RequestProgressSink } from '@agent-device/contracts/progress';
22
import net from 'node:net';
33
import { AppError } from '@agent-device/kernel/errors';
44
import { loadNodeHttpRequester, readNodeHttpResponseBody } from '@agent-device/host-kit/transport';
5+
import { abortedRequestError, refuseAbortedRequest } from '@agent-device/host-kit/request';
56
import type { DaemonRequest, DaemonResponse } from '../daemon/daemon-request.ts';
67
import { emitDiagnostic } from '@agent-device/host-kit/diagnostics';
78
import type { DaemonPaths, DaemonTransportPreference } from '../daemon-resolution.ts';
@@ -26,6 +27,13 @@ import { readVersion } from '@agent-device/host-kit/version';
2627
type ResolvedDaemonTransport = 'socket' | 'http';
2728
type 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

3139
const 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

‎src/daemon-client/daemon-client.ts‎

Lines changed: 37 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,7 @@ import {
1010
emitDiagnostic,
1111
withDiagnosticTimer,
1212
} from '@agent-device/host-kit/diagnostics';
13+
import { createRequestGuard } from '@agent-device/host-kit/request';
1314
import { INTERNAL_COMMANDS, PUBLIC_COMMANDS } from '@agent-device/command-registry/catalog';
1415
import { resolveCommandTimeoutPolicy } from '@agent-device/command-registry/registry';
1516
import { resolveCommandRequestTimeoutMs } from '@agent-device/command-registry/timeout-policy';
@@ -60,16 +61,28 @@ export async function sendToDaemon(
6061
resolveCommandTimeoutPolicy(requestWithoutAuthFlag.command),
6162
requestWithoutAuthFlag,
6263
);
63-
const daemon = await withDiagnosticTimer(
64-
'daemon_startup',
65-
async () => await ensureDaemon(settings),
66-
{ requestId, session: req.session },
67-
);
64+
// The caller's signal covers every phase of this one request: an already-aborted call is
65+
// refused before the daemon is even started or an artifact byte is uploaded, and an abort that
66+
// arrives mid-phase stops the upload and the request. Each phase's own machinery (the upload
67+
// client, the transports below) honors the signal; the guard turns any of those outcomes into
68+
// the typed canceled-request error, so an abort never borrows a timeout's shape.
69+
const cancellation = createRequestGuard({ signal: options.signal, requestId });
70+
cancellation.refuseIfAborted();
71+
const daemon = await cancellation.guard(async () => {
72+
return await withDiagnosticTimer('daemon_startup', async () => await ensureDaemon(settings), {
73+
requestId,
74+
session: req.session,
75+
});
76+
});
6877
const info = daemon.info;
69-
const preparedRemoteRequest = await protectArtifactUploadWithLeaseBeats(
70-
info,
71-
settings,
72-
requestWithoutAuthFlag,
78+
const preparedRemoteRequest = await cancellation.guard(
79+
async () =>
80+
await protectArtifactUploadWithLeaseBeats(
81+
info,
82+
settings,
83+
requestWithoutAuthFlag,
84+
options.signal,
85+
),
7386
);
7487
writeInstallInProgressNotice(requestWithoutAuthFlag.command);
7588

@@ -103,7 +116,7 @@ export async function sendToDaemon(
103116
settings.transportPreference,
104117
settings.paths,
105118
requestTimeoutMs,
106-
{ onProgress: options.onProgress },
119+
{ onProgress: options.onProgress, signal: options.signal },
107120
),
108121
{ requestId, command: req.command },
109122
);
@@ -316,15 +329,27 @@ async function protectArtifactUploadWithLeaseBeats(
316329
info: DaemonInfo,
317330
settings: DaemonClientSettings,
318331
request: Omit<DaemonRequest, 'token'>,
332+
callerSignal: AbortSignal | undefined,
319333
): Promise<PreparedRemoteRequest> {
320334
const leaseScope = leaseScopeFromRequest(request);
321335
if (!isRemoteDaemon(info) || !leaseScope.leaseId) {
322-
return await prepareRemoteRequestArtifacts(request, info, new AbortController().signal);
336+
return await prepareRemoteRequestArtifacts(
337+
request,
338+
info,
339+
callerSignal ?? new AbortController().signal,
340+
);
323341
}
324342
const { buildUploadLeaseHeartbeat, runProtectedLeaseWork } =
325343
await import('./daemon-client-lease-beat.ts');
326344
return await runProtectedLeaseWork({
327345
heartbeat: buildUploadLeaseHeartbeat(info, settings, request),
328-
task: (signal) => prepareRemoteRequestArtifacts(request, info, signal),
346+
// The upload stops for either owner of its signal: the lease beat finding the lease gone, or
347+
// the caller aborting this one call.
348+
task: (leaseSignal) =>
349+
prepareRemoteRequestArtifacts(
350+
request,
351+
info,
352+
callerSignal ? AbortSignal.any([leaseSignal, callerSignal]) : leaseSignal,
353+
),
329354
});
330355
}

0 commit comments

Comments
 (0)