@agent-device/proxy 0.0.0-stage → 0.21.23

package/dist/index.mjs

@@ -0,0 +1,463 @@
+import { r as normalizeError, t as AppError } from "./errors.mjs";
+import crypto, { randomUUID } from "node:crypto";
+import http from "node:http";
+//#region ../host-kit/src/internal/transport.ts
+/**
+* Compares two secret strings in constant time. Hashing both inputs first
+* keeps the comparison length-independent, so unequal-length tokens neither
+* throw nor leak length via timing.
+*/
+function timingSafeStringEqual(a, b) {
+	const hashA = crypto.createHash("sha256").update(a).digest();
+	const hashB = crypto.createHash("sha256").update(b).digest();
+	return crypto.timingSafeEqual(hashA, hashB);
+}
+//#endregion
+//#region ../contracts/src/daemon-http.ts
+const DAEMON_HTTP_BASE_PATH = "/agent-device";
+const DAEMON_HTTP_TENANT_HEADER = "x-agent-device-tenant";
+const DAEMON_HTTP_NETWORK_ACCESS_HEADER = "x-agent-device-network-access";
+const DAEMON_HTTP_PUBLIC_NETWORK_ACCESS = "public-only";
+function buildDaemonHttpUrl(baseUrl, route) {
+	const normalizedBase = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+	return new URL(route.replace(/^\/+/, ""), normalizedBase).toString();
+}
+function buildDaemonHttpAuthHeaders(token) {
+	const normalizedToken = token?.trim();
+	if (!normalizedToken) return {};
+	return {
+		authorization: `Bearer ${normalizedToken}`,
+		"x-agent-device-token": normalizedToken
+	};
+}
+const DAEMON_HTTP_INSTANCE_HEADER = "x-agent-device-instance";
+const DAEMON_HTTP_UPSTREAM_INSTANCE_HEADER = "x-agent-device-upstream-instance";
+const DAEMON_HTTP_INSTANCE_MISMATCH_HEADER = "x-agent-device-instance-mismatch";
+function buildDaemonInstanceMismatchRpcResponse(id, message, data) {
+	return {
+		jsonrpc: "2.0",
+		id,
+		error: {
+			code: -32001,
+			message,
+			data
+		}
+	};
+}
+function buildDaemonHealthPayload(service, version, options = {}) {
+	return {
+		ok: true,
+		service,
+		version,
+		rpcProtocolVersion: 2,
+		...options.instanceId !== void 0 ? { instanceId: options.instanceId } : {},
+		...options.hostArch !== void 0 ? { hostArch: options.hostArch } : {},
+		...options.leaseBackends !== void 0 ? { leaseBackends: options.leaseBackends } : {},
+		...options.upstream !== void 0 ? { upstream: options.upstream } : {}
+	};
+}
+//#endregion
+//#region src/install-source-admission.ts
+function carriesUnbackedHostPathInstallSource(rpcBody) {
+	const params = readRpcParams(rpcBody);
+	if (!params) return false;
+	const meta = readRecord(params.meta);
+	if (isBackedByUploadedArtifact(meta)) return false;
+	return isHostPathInstallSource(params.source) || isHostPathInstallSource(meta?.installSource);
+}
+function hostPathInstallSourceRefusedResponse(rpcId) {
+	const error = new AppError("INVALID_ARGS", "Invalid params: an install source of kind \"path\" names a file on the daemon host and is not accepted through the proxy", { hint: "Upload the artifact, or use a \"url\" or \"github-actions-artifact\" source." });
+	return Response.json({
+		jsonrpc: "2.0",
+		id: rpcId,
+		error: {
+			code: -32602,
+			message: error.message,
+			data: normalizeError(error)
+		}
+	}, { status: 400 });
+}
+function readRpcParams(rpcBody) {
+	if (!rpcBody) return void 0;
+	try {
+		return readRecord(readRecord(JSON.parse(rpcBody))?.params);
+	} catch {
+		return;
+	}
+}
+function isBackedByUploadedArtifact(meta) {
+	const uploadedArtifactId = meta?.uploadedArtifactId;
+	return typeof uploadedArtifactId === "string" && uploadedArtifactId.trim().length > 0;
+}
+function isHostPathInstallSource(source) {
+	return readRecord(source)?.kind === "path";
+}
+function readRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+//#endregion
+//#region src/daemon-proxy.ts
+const DEFAULT_MAX_RPC_BODY_BYTES = 1048576;
+const DEFAULT_UPSTREAM_TIMEOUT_MS = 3e5;
+const DAEMON_PROXY_PREFIX = `${DAEMON_HTTP_BASE_PATH}/`;
+const FORWARDED_REQUEST_HEADERS = [
+	"content-type",
+	"content-range",
+	"x-artifact-type",
+	"x-artifact-filename",
+	"x-artifact-hash",
+	"x-artifact-hash-algorithm",
+	DAEMON_HTTP_TENANT_HEADER
+];
+const FORWARDED_RESPONSE_HEADERS = [
+	"content-type",
+	"content-disposition",
+	"x-request-id",
+	DAEMON_HTTP_INSTANCE_MISMATCH_HEADER
+];
+function createDaemonProxy(options) {
+	const normalized = normalizeProxyOptions(options);
+	const instanceId = randomUUID();
+	return {
+		instanceId,
+		handle: async (request) => {
+			try {
+				return await handleProxyRequest(request, normalized, instanceId);
+			} catch (error) {
+				return proxyErrorResponse(error);
+			}
+		}
+	};
+}
+function createDaemonProxyServer(options) {
+	return http.createServer(createDaemonProxyRequestListener(createDaemonProxy(options)));
+}
+/** Serves a proxy from any `node:http` or `node:https` server; upload tickets follow its scheme. */
+function createDaemonProxyRequestListener(proxy) {
+	return (req, res) => {
+		import("./node-http.mjs").then(({ serveProxyRequest }) => serveProxyRequest(proxy, req, res)).catch((error) => {
+			if (!res.destroyed) res.destroy(error instanceof Error ? error : void 0);
+		});
+	};
+}
+async function handleProxyRequest(request, options, instanceId) {
+	const route = resolveProxyRoute(request.url);
+	if (request.method === "GET" && route === "/health") return await proxyHealthResponse(request, options, instanceId);
+	if (!isSupportedDaemonRoute(route, request.method)) return new Response(new TextEncoder().encode("Not found"), { status: 404 });
+	let rpcBody;
+	if (route === "/rpc") rpcBody = await readRequestText(request, options.maxRpcBodyBytes, "Proxy request body is too large.");
+	if (!isAuthorized(request, options.clientToken, rpcBody)) return unauthorizedResponse(route, readJsonRpcId(rpcBody));
+	const staleInstance = refuseStaleProxyInstance(request, route, readJsonRpcId(rpcBody), instanceId);
+	if (staleInstance) return staleInstance;
+	if (carriesUnbackedHostPathInstallSource(rpcBody)) return hostPathInstallSourceRefusedResponse(readJsonRpcId(rpcBody));
+	return await forwardProxyRequest({
+		request,
+		route,
+		options,
+		rpcBody
+	});
+}
+async function proxyHealthResponse(request, options, instanceId) {
+	const [upstream, { readVersion }, { readHostCpuArch }] = await Promise.all([
+		readUpstreamHealth(request, options),
+		import("./version.mjs"),
+		import("./process.mjs")
+	]);
+	return Response.json(buildDaemonHealthPayload("agent-device-proxy", readVersion(), {
+		upstream,
+		instanceId,
+		hostArch: await readHostCpuArch()
+	}));
+}
+async function readUpstreamHealth(request, options) {
+	const response = await options.upstreamFetch(new Request(buildDaemonHttpUrl(options.upstreamBaseUrl, "health"), {
+		method: "GET",
+		headers: buildUpstreamHeaders(new Headers(), options.upstreamToken, "/health"),
+		signal: upstreamSignal(request, options)
+	}));
+	const text = await response.text();
+	try {
+		return text ? JSON.parse(text) : {
+			ok: response.ok,
+			status: response.status
+		};
+	} catch {
+		return {
+			ok: response.ok,
+			status: response.status
+		};
+	}
+}
+async function forwardProxyRequest(params) {
+	const { request, route, options, rpcBody } = params;
+	const body = resolveUpstreamBody(request, route, rpcBody, options.upstreamToken);
+	const upstreamResponse = await options.upstreamFetch(new Request(buildUpstreamUrl(options.upstreamBaseUrl, route, request.url), {
+		method: request.method,
+		headers: buildUpstreamHeaders(request.headers, options.upstreamToken, route),
+		signal: upstreamSignal(request, options),
+		...body ? {
+			body,
+			duplex: "half"
+		} : {}
+	}));
+	const headers = copyProxyResponseHeaders(upstreamResponse, request);
+	if (isUploadPreflightRoute(route)) return await rewrittenUploadPreflightResponse({
+		request,
+		upstreamResponse,
+		headers,
+		clientToken: options.clientToken
+	});
+	return new Response(upstreamResponse.body, {
+		status: upstreamResponse.status,
+		headers
+	});
+}
+/**
+* An upstream exchange lives exactly as long as the client keeps waiting for it: the daemon
+* turns a dropped upstream request into cancellation of in-flight runner work.
+*/
+function upstreamSignal(request, options) {
+	return AbortSignal.any([request.signal, AbortSignal.timeout(options.upstreamTimeoutMs)]);
+}
+function copyProxyResponseHeaders(upstreamResponse, request) {
+	const headers = new Headers();
+	for (const name of FORWARDED_RESPONSE_HEADERS) {
+		const value = upstreamResponse.headers.get(name);
+		if (value) headers.set(name, value);
+	}
+	if (!headers.has("x-request-id")) headers.set("x-request-id", resolveRequestId(request));
+	return headers;
+}
+async function rewrittenUploadPreflightResponse(params) {
+	const { request, upstreamResponse, headers, clientToken } = params;
+	const text = await upstreamResponse.text();
+	headers.set("content-type", upstreamResponse.headers.get("content-type") ?? "application/json");
+	return new Response(rewriteUploadPreflightResponse(text, request, clientToken), {
+		status: upstreamResponse.status,
+		headers
+	});
+}
+function rewriteUploadPreflightResponse(body, request, clientToken) {
+	let parsed;
+	try {
+		parsed = JSON.parse(body);
+	} catch {
+		return body;
+	}
+	if (!parsed || typeof parsed !== "object") return body;
+	const record = parsed;
+	if (!record.upload || typeof record.upload.url !== "string") return body;
+	const rewrittenUrl = rewriteUploadDirectUrl(record.upload.url, request);
+	if (!rewrittenUrl) return body;
+	const headers = record.upload.headers && typeof record.upload.headers === "object" ? { ...record.upload.headers } : {};
+	Object.assign(headers, buildDaemonHttpAuthHeaders(clientToken));
+	return JSON.stringify({
+		...parsed,
+		upload: {
+			...record.upload,
+			url: rewrittenUrl,
+			headers
+		}
+	});
+}
+function rewriteUploadDirectUrl(upstreamUrl, request) {
+	let parsed;
+	try {
+		parsed = new URL(upstreamUrl);
+	} catch {
+		return null;
+	}
+	if (!parsed.pathname.startsWith("/upload/")) return null;
+	const requestUrl = new URL(request.url);
+	const uploadIndex = requestUrl.pathname.lastIndexOf("/upload/preflight");
+	const uploadPrefix = uploadIndex >= 0 ? requestUrl.pathname.slice(0, uploadIndex) : "";
+	const forwardedProto = request.headers.get("x-forwarded-proto")?.split(",")[0]?.trim();
+	const rewritten = new URL(`${forwardedProto || requestUrl.protocol.replace(/:$/, "")}://${requestUrl.host}`);
+	rewritten.pathname = `${uploadPrefix}${parsed.pathname}`;
+	rewritten.search = parsed.search;
+	return rewritten.toString();
+}
+function normalizeProxyOptions(options) {
+	return {
+		upstreamBaseUrl: normalizeBaseUrl(options.upstreamBaseUrl, "upstreamBaseUrl"),
+		upstreamToken: normalizeToken(options.upstreamToken, "upstreamToken"),
+		clientToken: normalizeToken(options.clientToken, "clientToken"),
+		maxRpcBodyBytes: options.maxRpcBodyBytes ?? DEFAULT_MAX_RPC_BODY_BYTES,
+		upstreamTimeoutMs: options.upstreamTimeoutMs ?? DEFAULT_UPSTREAM_TIMEOUT_MS,
+		upstreamFetch: options.upstreamFetch ?? ((request) => fetch(request))
+	};
+}
+function normalizeBaseUrl(value, label) {
+	try {
+		const parsed = new URL(value);
+		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error("unsupported protocol");
+		return parsed.toString().replace(/\/+$/, "");
+	} catch (error) {
+		throw new AppError("INVALID_ARGS", `Invalid ${label}`, { [label]: value }, error);
+	}
+}
+function normalizeToken(value, label) {
+	const token = value.trim();
+	if (!token) throw new AppError("INVALID_ARGS", `Proxy ${label} is required.`);
+	return token;
+}
+function resolveProxyRoute(requestUrl) {
+	const pathname = new URL(requestUrl).pathname;
+	if (pathname === "/agent-device") return "/";
+	if (pathname.startsWith(DAEMON_PROXY_PREFIX)) return `/${pathname.slice(DAEMON_PROXY_PREFIX.length)}`;
+	return pathname;
+}
+function isSupportedDaemonRoute(route, method) {
+	if (route === "/rpc") return method === "POST";
+	if (isSupportedUploadRoute(route, method)) return true;
+	if (route === "/artifacts" || route === "/artifacts/") return method === "GET";
+	if (route.startsWith("/artifacts/")) return method === "GET";
+	if (isRequestDiagnosticsRoute(route)) return method === "GET";
+	return false;
+}
+/**
+* `GET /sessions/<session>/requests/<requestId>/diagnostics` (#1801): the record a failed
+* command names. A remote client localizes its `logPath` from it, so a client behind the
+* proxy keeps exactly the failure envelope a client on the daemon host gets.
+*/
+function isRequestDiagnosticsRoute(route) {
+	const segments = route.split("/");
+	return segments.length === 6 && segments[1] === "sessions" && segments[3] === "requests" && segments[5] === "diagnostics" && segments[2] !== "" && segments[4] !== "";
+}
+function isSupportedUploadRoute(route, method) {
+	if (route === "/upload") return method === "POST";
+	if (isUploadPreflightRoute(route)) return method === "POST";
+	if (route === "/upload/finalize") return method === "POST";
+	if (route.startsWith("/upload/direct/")) return method === "PUT";
+	return false;
+}
+function isUploadPreflightRoute(route) {
+	return route === "/upload/preflight";
+}
+function buildUpstreamUrl(upstreamBaseUrl, route, requestUrl) {
+	const upstreamUrl = new URL(buildDaemonHttpUrl(upstreamBaseUrl, route));
+	upstreamUrl.search = new URL(requestUrl).search;
+	return upstreamUrl;
+}
+function buildUpstreamInstancePreconditionHeaders(requestHeaders) {
+	const expectedUpstreamInstance = requestHeaders.get(DAEMON_HTTP_UPSTREAM_INSTANCE_HEADER);
+	return expectedUpstreamInstance !== null ? { [DAEMON_HTTP_INSTANCE_HEADER]: expectedUpstreamInstance } : {};
+}
+function buildUpstreamHeaders(requestHeaders, upstreamToken, route) {
+	const headers = new Headers();
+	for (const name of FORWARDED_REQUEST_HEADERS) {
+		const value = requestHeaders.get(name);
+		if (value?.trim()) headers.set(name, value);
+	}
+	if (route === "/rpc" && !headers.has("content-type")) headers.set("content-type", "application/json");
+	if (route === "/rpc") {
+		headers.set(DAEMON_HTTP_NETWORK_ACCESS_HEADER, DAEMON_HTTP_PUBLIC_NETWORK_ACCESS);
+		for (const [name, value] of Object.entries(buildUpstreamInstancePreconditionHeaders(requestHeaders))) headers.set(name, value);
+	}
+	for (const [name, value] of Object.entries(buildDaemonHttpAuthHeaders(upstreamToken))) headers.set(name, value);
+	return headers;
+}
+function resolveUpstreamBody(request, route, rpcBody, upstreamToken) {
+	if (request.method === "GET" || request.method === "HEAD") return null;
+	if (route === "/rpc") return rewriteRpcToken(rpcBody ?? "", upstreamToken);
+	return request.body;
+}
+async function readRequestText(request, maxBodyBytes, tooLargeMessage) {
+	if (!request.body) return "";
+	const reader = request.body.getReader();
+	const chunks = [];
+	let bodyBytes = 0;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		bodyBytes += value.byteLength;
+		if (bodyBytes > maxBodyBytes) {
+			await reader.cancel();
+			throw new AppError("INVALID_ARGS", tooLargeMessage);
+		}
+		chunks.push(value);
+	}
+	return Buffer.concat(chunks).toString("utf8");
+}
+function isAuthorized(request, expectedToken, rpcBody) {
+	const requestToken = resolveRequestToken(request, rpcBody);
+	return requestToken.length > 0 && timingSafeStringEqual(requestToken, expectedToken);
+}
+function resolveRequestToken(request, rpcBody) {
+	const authHeader = request.headers.get("authorization") ?? "";
+	if (authHeader.toLowerCase().startsWith("bearer ")) return authHeader.slice(7);
+	const tokenHeader = request.headers.get("x-agent-device-token");
+	if (tokenHeader !== null) return tokenHeader;
+	if (rpcBody) {
+		const bodyToken = readJsonRpcToken(rpcBody);
+		if (bodyToken) return bodyToken;
+	}
+	return "";
+}
+function rewriteRpcToken(body, upstreamToken) {
+	const parsed = JSON.parse(body);
+	parsed.params = {
+		...parsed.params ?? {},
+		token: upstreamToken
+	};
+	return JSON.stringify(parsed);
+}
+function readJsonRpcToken(body) {
+	try {
+		const parsed = JSON.parse(body);
+		return typeof parsed.params?.token === "string" ? parsed.params.token : "";
+	} catch {
+		return "";
+	}
+}
+function readJsonRpcId(body) {
+	if (!body) return null;
+	try {
+		return JSON.parse(body).id ?? null;
+	} catch {
+		return null;
+	}
+}
+function resolveRequestId(request) {
+	const header = request.headers.get("x-request-id");
+	if (header?.trim()) return header.trim().slice(0, 128);
+	return randomUUID();
+}
+function refuseStaleProxyInstance(request, route, rpcId, instanceId) {
+	if (route !== "/rpc") return null;
+	const expectedInstanceId = request.headers.get(DAEMON_HTTP_INSTANCE_HEADER);
+	if (expectedInstanceId === null || expectedInstanceId === instanceId) return null;
+	return sendInstanceMismatch(rpcId);
+}
+function sendInstanceMismatch(rpcId) {
+	return Response.json(buildDaemonInstanceMismatchRpcResponse(rpcId, "Proxy instance changed", normalizeError(new AppError("COMMAND_FAILED", "Proxy instance changed", { reason: "remote_instance_mismatch" }))), {
+		status: 409,
+		headers: { [DAEMON_HTTP_INSTANCE_MISMATCH_HEADER]: "true" }
+	});
+}
+function unauthorizedResponse(route, rpcId) {
+	if (route === "/rpc") return Response.json({
+		jsonrpc: "2.0",
+		id: rpcId,
+		error: {
+			code: -32001,
+			message: "Invalid proxy token",
+			data: normalizeError(new AppError("UNAUTHORIZED", "Invalid proxy token"))
+		}
+	}, { status: 401 });
+	return Response.json({
+		ok: false,
+		error: "Invalid proxy token",
+		code: "UNAUTHORIZED"
+	}, { status: 401 });
+}
+function proxyErrorResponse(error) {
+	const normalized = normalizeError(error);
+	return Response.json({
+		ok: false,
+		error: normalized.message,
+		code: normalized.code
+	}, { status: normalized.code === "INVALID_ARGS" ? 400 : 500 });
+}
+//#endregion
+export { createDaemonProxy, createDaemonProxyRequestListener, createDaemonProxyServer };

package/dist/node-http.mjs

@@ -0,0 +1,68 @@
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { TLSSocket } from "node:tls";
+//#region src/node-http.ts
+async function serveProxyRequest(proxy, req, res) {
+	if (req.method === "TRACE") {
+		endWithStatus(res, 404);
+		return;
+	}
+	const url = requestUrl(req);
+	if (!url) {
+		endWithStatus(res, 400);
+		return;
+	}
+	const response = await proxy.handle(toWebRequest(url, req, res));
+	res.statusCode = response.status;
+	for (const [name, value] of response.headers) res.setHeader(name, value);
+	if (!response.body) {
+		res.end();
+		return;
+	}
+	await pipeline(Readable.fromWeb(response.body), res);
+}
+function endWithStatus(res, status) {
+	res.statusCode = status;
+	res.end();
+}
+/** `null` when the Host header and path do not form a URL that Fetch accepts. */
+function requestUrl(req) {
+	const scheme = req.socket instanceof TLSSocket ? "https" : "http";
+	const url = URL.parse(req.url ?? "/", `${scheme}://${req.headers.host ?? "127.0.0.1"}`);
+	if (!url || url.username || url.password) return null;
+	return url;
+}
+function toWebRequest(url, req, res) {
+	const method = req.method ?? "GET";
+	const hasBody = method !== "GET" && method !== "HEAD";
+	return new Request(url, {
+		method,
+		headers: toWebHeaders(req),
+		signal: clientGoneSignal(req, res),
+		...hasBody ? {
+			body: Readable.toWeb(req),
+			duplex: "half"
+		} : {}
+	});
+}
+function toWebHeaders(req) {
+	const headers = new Headers();
+	for (const [name, value] of Object.entries(req.headers)) {
+		if (value === void 0) continue;
+		for (const item of Array.isArray(value) ? value : [value]) headers.append(name, item);
+	}
+	return headers;
+}
+function clientGoneSignal(req, res) {
+	const clientGone = new AbortController();
+	const abortIfResponseIncomplete = () => {
+		if (res.writableFinished || clientGone.signal.aborted) return;
+		clientGone.abort(/* @__PURE__ */ new Error("Proxy client disconnected before the response ended"));
+	};
+	req.on("aborted", abortIfResponseIncomplete);
+	res.on("close", abortIfResponseIncomplete);
+	if (res.closed) abortIfResponseIncomplete();
+	return clientGone.signal;
+}
+//#endregion
+export { serveProxyRequest };