Repository navigation
Expand file tree
/
Copy pathtransport.ts
More file actions
209 lines (199 loc) · 7.87 KB
/
Copy pathtransport.ts
File metadata and controls
209 lines (199 loc) · 7.87 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
import type { DaemonResponse } from '@agent-device/kernel/contracts';
import { AppError, normalizeError, createRequestCanceledError } from '@agent-device/kernel/errors';
import { AsyncResource } from 'node:async_hooks';
import net from 'node:net';
import type { Server as HttpServer } from 'node:http';
import type { DaemonInvokeFn, DaemonRequest } from '../../core/daemon-request.ts';
import { resolveDaemonRequestResultDeadlineMs } from '../../core/daemon-command-registry.ts';
import {
clearRequestAbortRegistration,
isRequestCanceled,
markRequestCanceled,
registerRequestAbort,
resolveRequestTrackingId,
withRequestProgressSink,
} from '@agent-device/host-kit/request';
import { emitDiagnostic } from '@agent-device/host-kit/diagnostics';
import { consumeTextLines } from '@agent-device/host-kit/transport';
import { MAX_HTTP_RPC_BODY_BYTES } from './http-server.ts';
import {
serializeDaemonProgressEnvelope,
serializeDaemonResponseEnvelope,
shouldStreamRequestProgress,
} from '@agent-device/daemon-contracts/request-progress-protocol';
export type DaemonServer = (net.Server | HttpServer) & {
destroyConnections?: () => void;
};
export function createSocketServer(handleRequest: DaemonInvokeFn): DaemonServer {
const sockets = new Set<net.Socket>();
const server: DaemonServer = net.createServer((socket) => {
// An accepted socket loses the runtime that is listening, so its callbacks keep it explicitly.
sockets.add(socket);
socket.on(
'close',
AsyncResource.bind(() => sockets.delete(socket)),
);
let buffer = '';
let inFlightRequests = 0;
const activeRequestIds = new Set<string>();
let canceledInFlight = false;
// On disconnect, cancel only this connection's in-flight requests via their
// request-scoped AbortSignals. That aborts runner work owned by those requests
// without a global Apple runner abort, so an unrelated request's runner work
// (or non-Apple work) is never torn down by another client's disconnect.
const cancelInFlightRequests = () => {
if (canceledInFlight || inFlightRequests === 0) return;
canceledInFlight = true;
for (const requestId of activeRequestIds) {
markRequestCanceled(requestId);
}
emitDiagnostic({
level: 'warn',
phase: 'request_client_disconnected',
data: {
inFlightRequests,
},
});
};
socket.setEncoding('utf8');
socket.on('close', AsyncResource.bind(cancelInFlightRequests));
socket.on('error', AsyncResource.bind(cancelInFlightRequests));
// An oversized request ends the connection, but only after the complete requests framed
// before it are answered: the refusal is the last line this connection writes.
let oversizedRequestRefusalPending = false;
const refuseOversizedRequestWhenIdle = () => {
if (!oversizedRequestRefusalPending || inFlightRequests > 0 || socket.destroyed) return;
refuseOversizedSocketRequest(socket);
};
const answerSocketRequest = async (line: string): Promise<void> => {
let response: DaemonResponse;
inFlightRequests += 1;
let requestIdForCleanup: string | undefined;
let requestAbortRegistration: ReturnType<typeof registerRequestAbort>;
let streamProgress = false;
try {
const req = parseSocketDaemonRequest(line);
streamProgress = shouldStreamRequestProgress(req);
requestIdForCleanup = resolveRequestTrackingId(req.meta?.requestId, 'socket');
req.meta = {
...req.meta,
requestId: requestIdForCleanup,
};
requestAbortRegistration = registerRequestAbort(requestIdForCleanup, undefined, {
resultDeadlineMs: resolveDaemonRequestResultDeadlineMs(req),
});
activeRequestIds.add(requestIdForCleanup);
if (isRequestCanceled(requestIdForCleanup)) {
throw createRequestCanceledError();
}
response = await withRequestProgressSink(
streamProgress
? (event) => {
if (!socket.destroyed) {
socket.write(serializeDaemonProgressEnvelope(event));
}
}
: undefined,
async () => await handleRequest(req),
);
} catch (error) {
response = { ok: false, error: normalizeError(error) };
} finally {
inFlightRequests -= 1;
if (requestAbortRegistration) {
activeRequestIds.delete(requestAbortRegistration.requestId);
}
clearRequestAbortRegistration(requestAbortRegistration);
}
if (!socket.destroyed) {
socket.write(
streamProgress
? serializeDaemonResponseEnvelope(response)
: `${JSON.stringify(response)}\n`,
);
}
};
const onData = AsyncResource.bind(async (chunk: string) => {
if (oversizedRequestRefusalPending) return;
const framed = frameSocketRequests(buffer, chunk);
buffer = framed.buffer;
if (framed.oversized) {
oversizedRequestRefusalPending = true;
socket.off('data', onData);
}
for (const line of framed.lines) await answerSocketRequest(line);
refuseOversizedRequestWhenIdle();
});
socket.on('data', onData);
});
server.destroyConnections = () => {
for (const socket of sockets) {
socket.destroy();
}
sockets.clear();
};
return server;
}
/**
* Splits a chunk into the complete requests to answer. A request past the byte limit, framed or
* still unterminated, ends the framing: the requests before it are answered, nothing after it is.
*/
function frameSocketRequests(
buffer: string,
chunk: string,
): { lines: string[]; buffer: string; oversized: boolean } {
const parsed = consumeTextLines(buffer, chunk);
const oversizedLine = parsed.lines.findIndex(exceedsDaemonRequestLimit);
if (oversizedLine !== -1) {
return { lines: parsed.lines.slice(0, oversizedLine), buffer: '', oversized: true };
}
if (exceedsDaemonRequestLimit(parsed.buffer)) {
return { lines: parsed.lines, buffer: '', oversized: true };
}
return { ...parsed, oversized: false };
}
function exceedsDaemonRequestLimit(text: string): boolean {
return Buffer.byteLength(text, 'utf8') > MAX_HTTP_RPC_BODY_BYTES;
}
function refuseOversizedSocketRequest(socket: net.Socket): void {
const error = new AppError('INVALID_ARGS', 'Daemon request exceeds the size limit', {
maxBytes: MAX_HTTP_RPC_BODY_BYTES,
});
const response: DaemonResponse = { ok: false, error: normalizeError(error) };
socket.end(`${JSON.stringify(response)}\n`);
}
function parseSocketDaemonRequest(line: string): DaemonRequest {
const parsed = JSON.parse(line) as unknown;
if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
return parsed as DaemonRequest;
}
// `internal` carries daemon-issued capabilities and provenance. The socket is
// a public transport like HTTP, so a token-bearing client must not be able to
// forge those semantics even though the legacy socket request otherwise
// preserves its existing raw wire shape.
const { internal: _internal, ...request } = parsed as Record<string, unknown>;
return request as DaemonRequest;
}
export function listenNetServer(server: net.Server): Promise<number> {
return listenLoopbackServer(server, 'Failed to bind socket server');
}
export function listenHttpServer(server: HttpServer): Promise<number> {
return listenLoopbackServer(server, 'Failed to bind HTTP server');
}
function listenLoopbackServer(
server: net.Server | HttpServer,
errorMessage: string,
): Promise<number> {
return new Promise((resolve, reject) => {
server.once('error', reject);
server.listen(0, '127.0.0.1', () => {
server.off('error', reject);
const address = server.address();
if (typeof address === 'object' && address?.port) {
resolve(address.port);
return;
}
reject(new AppError('COMMAND_FAILED', errorMessage));
});
});
}