Repository navigation
Expand file tree
/
Copy pathproxy.ts
More file actions
118 lines (108 loc) · 4.11 KB
/
Copy pathproxy.ts
File metadata and controls
118 lines (108 loc) · 4.11 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
import { randomBytes } from 'node:crypto';
import { createDaemonProxyServer } from '@agent-device/proxy';
import { buildDaemonHttpBaseUrl } from '@agent-device/contracts/daemon-http';
import { ensureDaemonInfo } from '../../daemon-client/daemon-client-ensure.ts';
import { AppError } from '@agent-device/kernel/errors';
import { colorize, supportsColor } from '../../commands/output/color.ts';
import type { CliFlags } from '@agent-device/contracts/command';
import { writeCommandOutput } from './shared.ts';
import type { ClientCommandHandler } from './router-types.ts';
type ProxyStartup = {
proxyBaseUrl: string;
agentDeviceBaseUrl: string;
token: string;
upstreamBaseUrl: string;
stateDir: string;
};
export const proxyCommand: ClientCommandHandler = async ({ positionals, flags }) => {
if (positionals.length > 0) {
throw new AppError('INVALID_ARGS', 'proxy does not accept positional arguments.');
}
const startup = await startProxy(flags);
await writeCommandOutput(flags, startup, () => renderProxyStartup(startup));
await waitForever();
return true;
};
async function startProxy(flags: CliFlags): Promise<ProxyStartup> {
// The proxy fronts a local HTTP daemon. A responsive one it cannot use is replaced only when it
// holds no work; one that answers nothing is retired, as for any ensureDaemon caller.
const ensured = await ensureDaemonInfo({
stateDir: flags.stateDir,
daemonTransport: 'http',
daemonServerMode: 'http',
});
const daemon = ensured.daemon;
const upstreamBaseUrl = resolveLocalDaemonBaseUrl(daemon.info.httpPort);
const token = resolveProxyClientToken(flags);
const server = createDaemonProxyServer({
upstreamBaseUrl,
upstreamToken: daemon.info.token,
clientToken: token,
});
const host = flags.proxyHost?.trim() || '127.0.0.1';
const port = flags.proxyPort ?? 0;
await listen(server, host, port);
const address = server.address();
if (!address || typeof address === 'string') {
throw new AppError('COMMAND_FAILED', 'Proxy did not bind to a TCP address.');
}
const proxyBaseUrl = `http://${formatHostForUrl(address.address)}:${address.port}`;
return {
proxyBaseUrl,
agentDeviceBaseUrl: buildDaemonHttpBaseUrl(proxyBaseUrl),
token,
upstreamBaseUrl,
stateDir: ensured.stateDir,
};
}
function resolveLocalDaemonBaseUrl(httpPort: number | undefined): string {
if (!httpPort) {
throw new AppError('COMMAND_FAILED', 'Local daemon HTTP endpoint is unavailable.', {
hint: 'Retry after cleaning daemon state, or run proxy with a fresh --state-dir.',
});
}
return `http://127.0.0.1:${httpPort}`;
}
function resolveProxyClientToken(flags: CliFlags): string {
return flags.daemonAuthToken?.trim() || randomBytes(32).toString('hex');
}
function listen(server: ReturnType<typeof createDaemonProxyServer>, host: string, port: number) {
return new Promise<void>((resolve, reject) => {
server.once('error', reject);
server.listen(port, host, () => {
server.off('error', reject);
resolve();
});
});
}
function formatHostForUrl(host: string): string {
return host.includes(':') && !host.startsWith('[') ? `[${host}]` : host;
}
export function renderProxyStartup(
startup: ProxyStartup,
options: { useColor?: boolean } = {},
): string {
const useColor = options.useColor ?? supportsColor();
const checkmark = formatProxyOutputValue('✓', 'green', useColor);
const proxyBaseUrl = formatProxyOutputValue(startup.proxyBaseUrl, 'cyan', useColor);
const daemonBaseUrl = formatProxyOutputValue('<tunnel URL>', 'cyan', useColor);
const token = formatProxyOutputValue(startup.token, 'yellow', useColor);
return [
`${checkmark} Proxy listening at ${proxyBaseUrl}`,
'',
'Provide this to the agent-device instance connecting:',
'',
`Daemon base URL: ${daemonBaseUrl}`,
`Daemon auth token: ${token}`,
].join('\n');
}
function formatProxyOutputValue(
value: string,
format: Parameters<typeof colorize>[1],
useColor: boolean,
): string {
return useColor ? colorize(value, format, { validateStream: false }) : value;
}
function waitForever(): Promise<never> {
return new Promise(() => {});
}