Files
pipelines/web/src/peerRelay.js
T
alan 50535dc5ea Merge branch 'worktree-agent-a7f96a1eb9a56587d'
# Conflicts:
#	cmd/pipelines-server/main.go
#	internal/server/websocket.go
#	scripts/manage.py
#	scripts/setup-native.py
#	web/serve.mjs
#	web/src/peerRelay.js
2026-11-10 01:25:04 +00:00

217 lines
7.8 KiB
JavaScript

import {
endpoint,
webOrigin,
boundedRequest,
remoteRequest,
json,
} from "./peerTransport.js";
import { PeerRegistry } from "./peerRegistry.js";
import { withServerToken } from "./serverToken.js";
import { rememberDiscovered } from "./peerAddress.js";
// Peer files are untrusted content, never privileged control-UI documents.
// Apply this even for older peers whose /files endpoint has no sandbox header.
const contentPolicy =
"sandbox; default-src 'none'; script-src 'none'; connect-src 'none'; style-src 'unsafe-inline'; img-src 'self' data:; media-src 'self' data:; base-uri 'none'; form-action 'none'; frame-ancestors 'self'";
const allowed = (path) =>
path === "/files" ||
path === "/chat-uploads" ||
path.startsWith("/artifacts/") ||
path.startsWith("/updates/");
// Raw-body uploads: chat attachments and files stored into a home folder.
const postable = (path) => path === "/chat-uploads" || path === "/files";
export class PeerRelay extends PeerRegistry {
target(req, path) {
const parsed = new URL(req.url, "http://localhost");
const match = /^\/peers\/([^/]+)\/(.*)$/.exec(parsed.pathname);
if (!match) return null;
const owner = this.owner(req);
const peer = owner.peers.get(decodeURIComponent(match[1]));
if (!peer) throw new Error("Select and sign in to this server again");
const selected = endpoint(
parsed.searchParams.get("endpoint") ?? peer.active,
).href;
if (!peer.endpoints.includes(selected) || !peer.cookies.has(selected))
throw new Error("Server address is not signed in");
parsed.searchParams.delete("endpoint");
const url = new URL(path ?? `/${match[2]}`, webOrigin(selected));
url.search = parsed.search;
if (url.origin !== webOrigin(selected).origin)
throw new Error("Remote origin changed");
return { url, cookie: peer.cookies.get(selected), peer };
}
// Resolve the peer once for this request, check the answer against the
// address policy (peerAddress.js) and connect only to that address.
pinned(target, reply, send) {
this.policy
.pin(target.url)
.then((pin) => {
if (!reply.destroyed) send(pin.lookup);
})
.catch(() => {
if (typeof reply.writeHead !== "function")
reply.end("HTTP/1.1 403 Forbidden\r\nContent-Length: 0\r\n\r\n");
else if (!reply.headersSent)
json(reply, 403, { error: "Server address is not allowed" });
else reply.destroy();
});
}
http(req, res) {
if (!req.url.startsWith("/peers/")) return false;
try {
const target = this.target(req);
if (
!target ||
!allowed(target.url.pathname) ||
!["GET", "HEAD", "POST"].includes(req.method) ||
(req.method === "POST" && !postable(target.url.pathname))
) {
json(res, 404, { error: "Unsupported remote resource" });
return true;
}
this.pinned(target, res, (lookup) => {
const headers = { ...(target.cookie ? { cookie: target.cookie } : {}) };
for (const name of [
"content-type",
"content-length",
"range",
"x-file-name",
"x-upload-name",
"x-chat-file-name",
"x-pipelines-upload-name",
// The remote machine's own step-up token (POST /files).
"x-pipelines-elevation",
])
if (req.headers[name]) headers[name] = req.headers[name];
const upstream = remoteRequest(target.url, {
method: req.method,
lookup,
headers,
});
upstream.setTimeout(30000, () => upstream.destroy());
upstream.on("response", (response) => {
const safe = {};
for (const name of [
"content-type",
"content-length",
"content-range",
"accept-ranges",
"content-disposition",
])
if (response.headers[name]) safe[name] = response.headers[name];
res.writeHead(
response.statusCode >= 300 && response.statusCode < 400
? 502
: response.statusCode,
{
...safe,
"Cache-Control": "private, no-store",
// Multiple CSP policies intersect: preserve a peer's stricter
// restrictions while always imposing the local sandbox boundary.
"Content-Security-Policy": response.headers[
"content-security-policy"
]
? [response.headers["content-security-policy"], contentPolicy]
: contentPolicy,
"X-Content-Type-Options": "nosniff",
},
);
response.pipe(res);
});
upstream.on("error", () => {
if (!res.headersSent)
json(res, 502, { error: "Remote server unavailable" });
else res.destroy();
});
req.on("aborted", () => upstream.destroy());
res.on("close", () => upstream.destroy());
req.pipe(upstream);
});
} catch {
json(res, 401, { error: "Sign in to the remote server again" });
}
return true;
}
upgrade(req, socket, head) {
if (!req.url.startsWith("/peers/")) return false;
try {
const target = this.target(req, "/connect");
const headers = {
host: target.url.host,
connection: "Upgrade",
upgrade: "websocket",
"sec-websocket-key": req.headers["sec-websocket-key"],
"sec-websocket-version": "13",
...(target.cookie ? { cookie: target.cookie } : {}),
};
this.pinned(target, socket, (lookup) => {
const upstream = remoteRequest(target.url, { headers, lookup });
upstream.setTimeout(10000, () => upstream.destroy());
upstream.on("upgrade", (response, remote, remoteHead) => {
socket.write(
`HTTP/1.1 101 Switching Protocols\r\n${Object.entries(
response.headers,
)
.filter(([k]) =>
[
"upgrade",
"connection",
"sec-websocket-accept",
"sec-websocket-protocol",
].includes(k),
)
.map(([k, v]) => `${k}: ${v}`)
.join("\r\n")}\r\n\r\n`,
);
target.peer.sockets.add(socket);
remote.setTimeout(0);
socket.once("close", () => {
target.peer.sockets.delete(socket);
remote.destroy();
});
remote.once("close", () => socket.destroy());
socket.on("error", () => remote.destroy());
remote.on("error", () => socket.destroy());
if (head?.length) remote.write(head);
if (remoteHead?.length) socket.write(remoteHead);
remote.pipe(socket);
socket.pipe(remote);
});
upstream.on("response", (response) => {
response.resume();
socket.end(
`HTTP/1.1 ${response.statusCode === 401 ? 401 : 502} Remote Unavailable\r\nContent-Length: 0\r\n\r\n`,
);
});
upstream.on("error", () => socket.destroy());
socket.once("close", () => upstream.destroy());
upstream.end();
});
} catch {
socket.end("HTTP/1.1 401 Unauthorized\r\nContent-Length: 0\r\n\r\n");
}
return true;
}
}
export async function proxyDiscovery(req, res, host, port) {
try {
const response = await boundedRequest(
new URL(
`http://${host.includes(":") ? `[${host}]` : host}:${port}/discovery`,
),
{ headers: withServerToken({}) },
);
if (response.status === 200) rememberDiscovered(response.body);
res
.writeHead(response.status, {
"Content-Type": "application/json",
"Cache-Control": "no-store",
})
.end(response.body);
} catch {
json(res, 503, { error: "LAN discovery unavailable" });
}
}