Repository navigation
Expand file tree
/
Copy pathtakeover-hold-admin.ts
More file actions
195 lines (184 loc) · 6.83 KB
/
Copy pathtakeover-hold-admin.ts
File metadata and controls
195 lines (184 loc) · 6.83 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
import { buildDaemonHttpAuthHeaders } from '@agent-device/contracts/daemon-http';
import type {
HumanControlHold,
HumanControlHoldOptions,
HumanControlHoldScope,
} from '@agent-device/contracts/client';
import type { CliFlags } from '@agent-device/contracts/command';
import { normalizeHumanControlHold } from '@agent-device/client';
import { readRegisteredDaemon } from '@agent-device/daemon-client';
import { resolveDaemonPaths } from '@agent-device/daemon-contracts/daemon-resolution';
import { AppError, toAppErrorCode } from '@agent-device/kernel/errors';
import type { HostEnvironment } from '@agent-device/kernel/source-value';
import {
loadNodeHttpRequester,
readNodeHttpResponseBody,
type NodeHttpRequester,
} from '@agent-device/host-kit/transport';
const HOST_HOLD_HTTP_TIMEOUT_MS = 10_000;
/** The daemon host-admin surface `takeover hold` and host `takeover release` ride. */
export type HostHoldAdminConnection = {
baseUrl: string;
token?: string;
};
export type HostHoldAdminRequester = Pick<NodeHttpRequester, 'request'>;
/**
* Names the daemon a host hold rides: the explicit base URL and token when the
* operator passed them, else the local daemon's loopback HTTP listener and its
* own token. It never starts a daemon; a hold must outlive this one command.
*/
export async function resolveHostHoldAdmin(
flags: CliFlags,
host: HostEnvironment,
): Promise<HostHoldAdminConnection> {
const baseUrl = flags.daemonBaseUrl?.trim().replace(/\/+$/, '');
if (baseUrl !== undefined && baseUrl !== '') {
assertHttpBaseUrl(baseUrl);
const token = flags.daemonAuthToken?.trim();
return { baseUrl, ...(token ? { token } : {}) };
}
const paths = resolveDaemonPaths(flags.stateDir, { env: host.env, cwd: host.cwd });
const info = await readRegisteredDaemon(paths);
if (!info) {
throw new AppError('COMMAND_FAILED', `No daemon is registered in ${paths.baseDir}.`, {
reason: 'daemon-not-running',
stateDir: paths.baseDir,
hint: 'Run any agent-device command once to start the local daemon, or pass --daemon-base-url and --daemon-auth-token.',
});
}
if (!info.httpPort) {
throw new AppError(
'UNSUPPORTED_OPERATION',
'The local daemon has no HTTP listener for the host hold API.',
{
reason: 'daemon-http-listener-missing',
...(info.transport ? { transport: info.transport } : {}),
hint: 'Start the daemon with --daemon-server-mode http or dual, or pass --daemon-base-url and --daemon-auth-token.',
},
);
}
return { baseUrl: `http://127.0.0.1:${info.httpPort}`, token: info.token };
}
export async function putHostHumanControlHold(params: {
connection: HostHoldAdminConnection;
holdId: string;
scope: HumanControlHoldScope;
input: HumanControlHoldOptions;
requester?: HostHoldAdminRequester;
}): Promise<HumanControlHold> {
const { connection, holdId } = params;
const url = new URL(
`${connection.baseUrl}/admin/human-control/holds/${encodeURIComponent(holdId)}`,
);
const response = await requestJson({
method: 'PUT',
url,
token: connection.token,
body: { scope: params.scope, ...params.input },
requester: params.requester,
});
return normalizeHumanControlHold(response.hold);
}
export async function removeHostHumanControlHold(params: {
connection: HostHoldAdminConnection;
holdId: string;
requester?: HostHoldAdminRequester;
}): Promise<boolean> {
const { connection, holdId } = params;
const url = new URL(
`${connection.baseUrl}/admin/human-control/holds/${encodeURIComponent(holdId)}`,
);
const response = await requestJson({
method: 'DELETE',
url,
token: connection.token,
requester: params.requester,
});
return response.released === true;
}
function assertHttpBaseUrl(baseUrl: string): void {
let url: URL;
try {
url = new URL(baseUrl);
} catch {
throw new AppError('INVALID_ARGS', '--daemon-base-url must be a valid URL.', {
reason: 'daemon-base-url-invalid',
});
}
if (url.protocol !== 'http:' && url.protocol !== 'https:') {
throw new AppError('INVALID_ARGS', '--daemon-base-url must be an http or https URL.', {
reason: 'daemon-base-url-invalid',
});
}
}
async function requestJson(params: {
method: 'PUT' | 'DELETE';
url: URL;
token?: string;
body?: unknown;
requester?: HostHoldAdminRequester;
}): Promise<Record<string, unknown>> {
const requester = params.requester ?? (await loadNodeHttpRequester(params.url.protocol));
const body = params.body === undefined ? undefined : JSON.stringify(params.body);
const { status, raw } = await new Promise<{ status: number; raw: string }>((resolve, reject) => {
const request = requester.request(
{
protocol: params.url.protocol,
host: params.url.hostname,
...(params.url.port ? { port: Number(params.url.port) } : {}),
path: `${params.url.pathname}${params.url.search}`,
method: params.method,
headers: {
...buildDaemonHttpAuthHeaders(params.token),
...(body === undefined ? {} : { 'content-type': 'application/json' }),
...(body === undefined ? {} : { 'content-length': Buffer.byteLength(body) }),
},
},
(response) => {
readNodeHttpResponseBody(response).then(
(raw) => resolve({ status: response.statusCode ?? 0, raw }),
reject,
);
},
);
request.on('error', reject);
request.setTimeout(HOST_HOLD_HTTP_TIMEOUT_MS, () => {
request.destroy(new AppError('COMMAND_FAILED', 'The daemon host hold request timed out.'));
});
request.end(body);
});
return readHostHoldResponse(status, raw);
}
function readHostHoldResponse(status: number, raw: string): Record<string, unknown> {
const parsed: unknown = raw.trim() === '' ? undefined : JSON.parse(raw);
if (status < 200 || status > 299) throw hostHoldRestError(status, parsed);
if (!isRecord(parsed) || parsed.ok !== true) {
throw new AppError('COMMAND_FAILED', 'The daemon returned an invalid host hold response.', {
statusCode: status,
});
}
return parsed;
}
function hostHoldRestError(status: number, parsed: unknown): AppError {
const record = isRecord(parsed) ? parsed : undefined;
const code = toAppErrorCode(
typeof record?.code === 'string' ? record.code : undefined,
'COMMAND_FAILED',
);
const reason = typeof record?.reason === 'string' ? record.reason : undefined;
const hint = typeof record?.hint === 'string' ? record.hint : undefined;
return new AppError(
code,
typeof record?.error === 'string'
? record.error
: `The daemon refused the host hold request (HTTP ${status}).`,
{
statusCode: status,
...(reason ? { reason } : {}),
...(hint ? { hint } : {}),
},
);
}
function isRecord(value: unknown): value is Record<string, unknown> {
return typeof value === 'object' && value !== null && !Array.isArray(value);
}