@agimon-ai/doompi-core 0.0.1-alpha.100

package/dist/readiness.cjs

@@ -0,0 +1,8 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_readiness = require("./src/schemas/readiness.cjs");
+exports.DOOM_READINESS_ERROR_CODE = require_readiness.DOOM_READINESS_ERROR_CODE;
+exports.DOOM_READINESS_SERVICE = require_readiness.DOOM_READINESS_SERVICE;
+exports.DoomReadinessError = require_readiness.DoomReadinessError;
+exports.createDoomReadinessCoordinator = require_readiness.createDoomReadinessCoordinator;
+exports.readDoomReadinessCoordinator = require_readiness.readDoomReadinessCoordinator;
+exports.requireDoomReadinessCoordinator = require_readiness.requireDoomReadinessCoordinator;

package/dist/readiness.d.mts

@@ -0,0 +1,2 @@
+import { DOOM_READINESS_ERROR_CODE, DOOM_READINESS_SERVICE, DoomReadinessCoordinator, DoomReadinessCoordinatorOptions, DoomReadinessError, DoomReadinessErrorCode, DoomReadinessErrorDetail, DoomReadinessErrorOptions, DoomReadinessHandle, DoomReadinessNotification, DoomReadinessSnapshot, DoomReadinessState, DoomReadinessTask, DoomReadinessTaskResult, DoomReadinessWaitOptions, createDoomReadinessCoordinator, readDoomReadinessCoordinator, requireDoomReadinessCoordinator } from "./src/schemas/readiness.mjs";
+export { DOOM_READINESS_ERROR_CODE, DOOM_READINESS_SERVICE, type DoomReadinessCoordinator, type DoomReadinessCoordinatorOptions, DoomReadinessError, type DoomReadinessErrorCode, type DoomReadinessErrorDetail, type DoomReadinessErrorOptions, type DoomReadinessHandle, type DoomReadinessNotification, type DoomReadinessSnapshot, type DoomReadinessState, type DoomReadinessTask, type DoomReadinessTaskResult, type DoomReadinessWaitOptions, createDoomReadinessCoordinator, readDoomReadinessCoordinator, requireDoomReadinessCoordinator };

package/dist/readiness.mjs

@@ -0,0 +1,2 @@
+import { DOOM_READINESS_ERROR_CODE, DOOM_READINESS_SERVICE, DoomReadinessError, createDoomReadinessCoordinator, readDoomReadinessCoordinator, requireDoomReadinessCoordinator } from "./src/schemas/readiness.mjs";
+export { DOOM_READINESS_ERROR_CODE, DOOM_READINESS_SERVICE, DoomReadinessError, createDoomReadinessCoordinator, readDoomReadinessCoordinator, requireDoomReadinessCoordinator };

package/dist/relaunchHandoff.cjs

@@ -0,0 +1,6 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_relaunchHandoff = require("./src/schemas/relaunchHandoff.cjs");
+exports.DOOM_RELAUNCH_FILE_ENV = require_relaunchHandoff.DOOM_RELAUNCH_FILE_ENV;
+exports.RelaunchHandoffSchema = require_relaunchHandoff.RelaunchHandoffSchema;
+exports.parseRelaunchHandoff = require_relaunchHandoff.parseRelaunchHandoff;
+exports.serializeRelaunchHandoff = require_relaunchHandoff.serializeRelaunchHandoff;

package/dist/relaunchHandoff.d.mts

@@ -0,0 +1,2 @@
+import { DOOM_RELAUNCH_FILE_ENV, RelaunchHandoff, RelaunchHandoffSchema, parseRelaunchHandoff, serializeRelaunchHandoff } from "./src/schemas/relaunchHandoff.mjs";
+export { DOOM_RELAUNCH_FILE_ENV, type RelaunchHandoff, RelaunchHandoffSchema, parseRelaunchHandoff, serializeRelaunchHandoff };

package/dist/relaunchHandoff.mjs

@@ -0,0 +1,2 @@
+import { DOOM_RELAUNCH_FILE_ENV, RelaunchHandoffSchema, parseRelaunchHandoff, serializeRelaunchHandoff } from "./src/schemas/relaunchHandoff.mjs";
+export { DOOM_RELAUNCH_FILE_ENV, RelaunchHandoffSchema, parseRelaunchHandoff, serializeRelaunchHandoff };

package/dist/remoteApi.cjs

@@ -0,0 +1,42 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/server/remoteApi.ts
+/** Global package mount for the machine's Remote Control service. */
+const remoteApi = {
+	basePath: "remote",
+	start(context) {
+		if (context.scope !== "global" || !context.remoteControl) throw new Error("Remote Control requires the global headless host.");
+		const control = context.remoteControl;
+		let closed = false;
+		return {
+			fetch(request) {
+				if (closed) return Response.json({ error: "Remote Control is closed." }, { status: 503 });
+				const origin = request.headers.get("origin");
+				if (origin !== null) {
+					let allowed = false;
+					try {
+						const parsed = new URL(origin);
+						allowed = parsed.protocol === "http:" && [
+							"127.0.0.1",
+							"localhost",
+							"[::1]"
+						].includes(parsed.hostname);
+					} catch {
+						allowed = false;
+					}
+					if (!allowed) return Response.json({ error: "That origin may not control this cockpit." }, { status: 403 });
+				}
+				const from = new URL(request.url);
+				const suffix = from.pathname === "/" ? "" : from.pathname;
+				const target = new URL(`/api/remote${suffix}${from.search}`, "http://doompi.local");
+				return control.fetch(new Request(target, request));
+			},
+			close() {
+				closed = true;
+			}
+		};
+	}
+};
+//#endregion
+exports.remoteApi = remoteApi;
+
+//# sourceMappingURL=remoteApi.cjs.map

package/dist/remoteApi.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"remoteApi.cjs","names":[],"sources":["../src/server/remoteApi.ts"],"sourcesContent":["import type { DoomApi } from '../exports/packageApi';\n\n/** Global package mount for the machine's Remote Control service. */\nexport const remoteApi: DoomApi = {\n  basePath: 'remote',\n  start(context) {\n    if (context.scope !== 'global' || !context.remoteControl)\n      throw new Error('Remote Control requires the global headless host.');\n    const control = context.remoteControl;\n    let closed = false;\n    return {\n      fetch(request) {\n        if (closed) return Response.json({ error: 'Remote Control is closed.' }, { status: 503 });\n        const origin = request.headers.get('origin');\n        if (origin !== null) {\n          let allowed = false;\n          try {\n            const parsed = new URL(origin);\n            allowed = parsed.protocol === 'http:' && ['127.0.0.1', 'localhost', '[::1]'].includes(parsed.hostname);\n          } catch {\n            allowed = false;\n          }\n          if (!allowed) return Response.json({ error: 'That origin may not control this cockpit.' }, { status: 403 });\n        }\n        const from = new URL(request.url);\n        const suffix = from.pathname === '/' ? '' : from.pathname;\n        const target = new URL(`/api/remote${suffix}${from.search}`, 'http://doompi.local');\n        return control.fetch(new Request(target, request));\n      },\n      close() {\n        closed = true;\n      },\n    };\n  },\n};\n"],"mappings":";;;AAGA,MAAa,YAAqB;CAChC,UAAU;CACV,MAAM,SAAS;EACb,IAAI,QAAQ,UAAU,YAAY,CAAC,QAAQ,eACzC,MAAM,IAAI,MAAM,mDAAmD;EACrE,MAAM,UAAU,QAAQ;EACxB,IAAI,SAAS;EACb,OAAO;GACL,MAAM,SAAS;IACb,IAAI,QAAQ,OAAO,SAAS,KAAK,EAAE,OAAO,4BAA4B,GAAG,EAAE,QAAQ,IAAI,CAAC;IACxF,MAAM,SAAS,QAAQ,QAAQ,IAAI,QAAQ;IAC3C,IAAI,WAAW,MAAM;KACnB,IAAI,UAAU;KACd,IAAI;MACF,MAAM,SAAS,IAAI,IAAI,MAAM;MAC7B,UAAU,OAAO,aAAa,WAAW;OAAC;OAAa;OAAa;MAAO,CAAC,CAAC,SAAS,OAAO,QAAQ;KACvG,QAAQ;MACN,UAAU;KACZ;KACA,IAAI,CAAC,SAAS,OAAO,SAAS,KAAK,EAAE,OAAO,4CAA4C,GAAG,EAAE,QAAQ,IAAI,CAAC;IAC5G;IACA,MAAM,OAAO,IAAI,IAAI,QAAQ,GAAG;IAChC,MAAM,SAAS,KAAK,aAAa,MAAM,KAAK,KAAK;IACjD,MAAM,SAAS,IAAI,IAAI,cAAc,SAAS,KAAK,UAAU,qBAAqB;IAClF,OAAO,QAAQ,MAAM,IAAI,QAAQ,QAAQ,OAAO,CAAC;GACnD;GACA,QAAQ;IACN,SAAS;GACX;EACF;CACF;AACF"}

package/dist/remoteApi.d.mts

@@ -0,0 +1,7 @@
+import { DoomApi } from "./src/schemas/packageApi.mjs";
+import "./packageApi.mjs";
+//#region src/server/remoteApi.d.ts
+/** Global package mount for the machine's Remote Control service. */
+export declare const remoteApi: DoomApi;
+//#endregion
+//# sourceMappingURL=remoteApi.d.mts.map

package/dist/remoteApi.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remoteApi.d.mts","names":[],"sources":["../src/server/remoteApi.ts"],"mappings":";;;;qBAGa,WAAW"}

package/dist/remoteApi.mjs

@@ -0,0 +1,41 @@
+//#region src/server/remoteApi.ts
+/** Global package mount for the machine's Remote Control service. */
+const remoteApi = {
+	basePath: "remote",
+	start(context) {
+		if (context.scope !== "global" || !context.remoteControl) throw new Error("Remote Control requires the global headless host.");
+		const control = context.remoteControl;
+		let closed = false;
+		return {
+			fetch(request) {
+				if (closed) return Response.json({ error: "Remote Control is closed." }, { status: 503 });
+				const origin = request.headers.get("origin");
+				if (origin !== null) {
+					let allowed = false;
+					try {
+						const parsed = new URL(origin);
+						allowed = parsed.protocol === "http:" && [
+							"127.0.0.1",
+							"localhost",
+							"[::1]"
+						].includes(parsed.hostname);
+					} catch {
+						allowed = false;
+					}
+					if (!allowed) return Response.json({ error: "That origin may not control this cockpit." }, { status: 403 });
+				}
+				const from = new URL(request.url);
+				const suffix = from.pathname === "/" ? "" : from.pathname;
+				const target = new URL(`/api/remote${suffix}${from.search}`, "http://doompi.local");
+				return control.fetch(new Request(target, request));
+			},
+			close() {
+				closed = true;
+			}
+		};
+	}
+};
+//#endregion
+export { remoteApi };
+
+//# sourceMappingURL=remoteApi.mjs.map

package/dist/remoteApi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"remoteApi.mjs","names":[],"sources":["../src/server/remoteApi.ts"],"sourcesContent":["import type { DoomApi } from '../exports/packageApi';\n\n/** Global package mount for the machine's Remote Control service. */\nexport const remoteApi: DoomApi = {\n  basePath: 'remote',\n  start(context) {\n    if (context.scope !== 'global' || !context.remoteControl)\n      throw new Error('Remote Control requires the global headless host.');\n    const control = context.remoteControl;\n    let closed = false;\n    return {\n      fetch(request) {\n        if (closed) return Response.json({ error: 'Remote Control is closed.' }, { status: 503 });\n        const origin = request.headers.get('origin');\n        if (origin !== null) {\n          let allowed = false;\n          try {\n            const parsed = new URL(origin);\n            allowed = parsed.protocol === 'http:' && ['127.0.0.1', 'localhost', '[::1]'].includes(parsed.hostname);\n          } catch {\n            allowed = false;\n          }\n          if (!allowed) return Response.json({ error: 'That origin may not control this cockpit.' }, { status: 403 });\n        }\n        const from = new URL(request.url);\n        const suffix = from.pathname === '/' ? '' : from.pathname;\n        const target = new URL(`/api/remote${suffix}${from.search}`, 'http://doompi.local');\n        return control.fetch(new Request(target, request));\n      },\n      close() {\n        closed = true;\n      },\n    };\n  },\n};\n"],"mappings":";;AAGA,MAAa,YAAqB;CAChC,UAAU;CACV,MAAM,SAAS;EACb,IAAI,QAAQ,UAAU,YAAY,CAAC,QAAQ,eACzC,MAAM,IAAI,MAAM,mDAAmD;EACrE,MAAM,UAAU,QAAQ;EACxB,IAAI,SAAS;EACb,OAAO;GACL,MAAM,SAAS;IACb,IAAI,QAAQ,OAAO,SAAS,KAAK,EAAE,OAAO,4BAA4B,GAAG,EAAE,QAAQ,IAAI,CAAC;IACxF,MAAM,SAAS,QAAQ,QAAQ,IAAI,QAAQ;IAC3C,IAAI,WAAW,MAAM;KACnB,IAAI,UAAU;KACd,IAAI;MACF,MAAM,SAAS,IAAI,IAAI,MAAM;MAC7B,UAAU,OAAO,aAAa,WAAW;OAAC;OAAa;OAAa;MAAO,CAAC,CAAC,SAAS,OAAO,QAAQ;KACvG,QAAQ;MACN,UAAU;KACZ;KACA,IAAI,CAAC,SAAS,OAAO,SAAS,KAAK,EAAE,OAAO,4CAA4C,GAAG,EAAE,QAAQ,IAAI,CAAC;IAC5G;IACA,MAAM,OAAO,IAAI,IAAI,QAAQ,GAAG;IAChC,MAAM,SAAS,KAAK,aAAa,MAAM,KAAK,KAAK;IACjD,MAAM,SAAS,IAAI,IAAI,cAAc,SAAS,KAAK,UAAU,qBAAqB;IAClF,OAAO,QAAQ,MAAM,IAAI,QAAQ,QAAQ,OAAO,CAAC;GACnD;GACA,QAAQ;IACN,SAAS;GACX;EACF;CACF;AACF"}

package/dist/remoteRuntime.cjs

@@ -0,0 +1,460 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_packageApi = require("./src/schemas/packageApi.cjs");
+const require_sessionMcpRoutes = require("./src/server/sessionMcpRoutes.cjs");
+const require_remote = require("./src/constants/remote.cjs");
+const require_index = require("./src/services/devProxyPolicy/index.cjs");
+const require_index$1 = require("./src/services/devProxyStore/index.cjs");
+const require_index$2 = require("./src/services/remoteGuardPolicy/index.cjs");
+const require_index$3 = require("./src/services/webauthnPolicy/index.cjs");
+const require_index$4 = require("./src/services/remoteAccess/index.cjs");
+const require_index$5 = require("./src/services/remoteAccessStore/index.cjs");
+const require_index$6 = require("./src/services/tunnelProcess/index.cjs");
+const require_devProxyRoutes = require("./src/server/devProxyRoutes.cjs");
+const require_devProxySocket = require("./src/server/devProxySocket.cjs");
+const require_remoteRoutes = require("./src/server/remoteRoutes.cjs");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path, 1);
+let node_http = require("node:http");
+let node_stream = require("node:stream");
+let node_stream_promises = require("node:stream/promises");
+let ws = require("ws");
+ws = require_runtime.__toESM(ws, 1);
+let hono = require("hono");
+let hono_cookie = require("hono/cookie");
+//#region src/server/remoteRuntime.ts
+const MAX_REQUEST_BYTES = 8388608;
+const TUNNEL_HEADERS_TIMEOUT_MS = 5e3;
+const TUNNEL_REQUEST_TIMEOUT_MS = 1e4;
+const TUNNEL_CONNECTION_LIMIT = 64;
+const TUNNEL_REQUESTS_PER_SOCKET = 100;
+const SEALED_HTTP_VERSION = 1;
+const SEALED_HTTP_METHODS = /* @__PURE__ */ new Set([
+	"GET",
+	"HEAD",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE"
+]);
+/** HMAC-authenticated peer routes are the only non-device tunnel APIs. */
+const SESSION_PEER_INBOX_ROUTE = "/api/plugins/session-peer/inbox";
+const VOICE_PEER_ROUTES = /* @__PURE__ */ new Set(["/api/plugins/voice/peer", "/api/plugins/voice/peer-ownership"]);
+const FORBIDDEN_HEADERS = /* @__PURE__ */ new Set([
+	"authorization",
+	"connection",
+	"content-length",
+	"cookie",
+	"forwarded",
+	"host",
+	"origin",
+	"transfer-encoding",
+	"upgrade",
+	"x-doompi-token",
+	"x-forwarded-for",
+	"x-forwarded-host",
+	"x-forwarded-proto"
+]);
+function sealedRequest(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const request = value;
+	if (request.v !== SEALED_HTTP_VERSION || typeof request.method !== "string" || !SEALED_HTTP_METHODS.has(request.method) || typeof request.target !== "string" || !request.target.startsWith("/") || request.target.startsWith("//") || request.target.includes("#") || !Array.isArray(request.headers) || !request.headers.every((header) => Array.isArray(header) && header.length === 2 && header.every((part) => typeof part === "string")) || request.body !== void 0 && typeof request.body !== "string") return void 0;
+	const parsed = new URL(request.target, "http://doompi.local");
+	if (parsed.pathname === require_remote.REMOTE_HTTP_ROUTE || parsed.pathname === require_remote.REMOTE_CHANNEL_ROUTE) return void 0;
+	return request;
+}
+function decodedBody(value) {
+	if (value === void 0) return Buffer.alloc(0);
+	if (!/^(?:[A-Za-z\d+/]{4})*(?:[A-Za-z\d+/]{2}==|[A-Za-z\d+/]{3}=)?$/u.test(value)) return void 0;
+	const body = Buffer.from(value, "base64");
+	return body.toString("base64") === value ? body : void 0;
+}
+async function readBody(request) {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of request) {
+		const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		size += bytes.byteLength;
+		if (size > MAX_REQUEST_BYTES) throw new Error("The tunnel request body is too large.");
+		chunks.push(bytes);
+	}
+	return Buffer.concat(chunks);
+}
+async function writeResponse(response, result) {
+	response.writeHead(result.status, Object.fromEntries(result.headers.entries()));
+	if (result.body === null) {
+		response.end();
+		return;
+	}
+	await (0, node_stream_promises.pipeline)(node_stream.Readable.fromWeb(result.body), response);
+}
+/** One global control plane and a second socket dedicated to public tunnel traffic. */
+function createRemoteRuntime(options) {
+	const store = require_index$5.createRemoteAccessStore({
+		stateDir: node_path.default.join(options.homeDirectory, ".doompi", "web"),
+		onNotice: (message) => options.onNotice(message)
+	});
+	require_index$6.reapStaleTunnel(store.directory, (message) => options.onNotice(message));
+	const devProxy = require_index$1.createDevProxyStore({
+		stateDir: store.directory,
+		onNotice: (message) => options.onNotice(message)
+	});
+	const app = new hono.Hono();
+	let remote;
+	let frontendOrigin;
+	app.use("*", async (context, next) => {
+		if (context.env.listener === "local") return next();
+		const path = context.req.path;
+		const publicSessionMcp = require_sessionMcpRoutes.isPublicSessionMcpRoute(context.req.method, path);
+		const publicSessionPeer = context.req.method === "POST" && path === SESSION_PEER_INBOX_ROUTE;
+		const publicVoicePeer = context.req.method === "POST" && VOICE_PEER_ROUTES.has(path);
+		const verdict = require_index$2.originVerdict({
+			listener: "tunnel",
+			method: publicSessionMcp || publicSessionPeer || publicVoicePeer ? "GET" : context.req.method,
+			isUpgrade: false,
+			origin: context.req.header("origin"),
+			host: context.req.header("host"),
+			local: require_index$2.localOriginPolicy(0),
+			tunnel: remote.tunnelPolicy()
+		});
+		if (verdict !== "allow") return context.json({ error: `Tunnel request refused: ${verdict}.` }, 403);
+		if (require_index$2.isPublicPairingRoute(context.req.method, path) || publicSessionMcp || publicSessionPeer || publicVoicePeer) return next();
+		const device = remote.authorize((0, hono_cookie.getCookie)(context, require_remote.DEVICE_COOKIE, "host"));
+		if (device === void 0) return context.json({ error: "This device is not paired." }, 401);
+		if (context.env.sealedDeviceId === device) return next();
+		if (require_index.isDevProxyPath(path)) return next();
+		if (context.req.method === "POST" && (path === require_remote.REMOTE_CHANNEL_ROUTE || path === require_remote.REMOTE_HTTP_ROUTE)) return next();
+		if ((context.req.method === "GET" || context.req.method === "HEAD") && !path.startsWith("/api/")) return next();
+		return context.json({ error: "Remote HTTP requests must use the sealed gateway." }, 401);
+	});
+	remote = require_index$4.createRemoteAccess({
+		store,
+		launchTunnel: options.launchTunnel ?? require_index$6.createTunnelLauncher({
+			stateDir: store.directory,
+			onNotice: (message) => options.onNotice(message),
+			onExit: (message) => {
+				options.onNotice(`remote access: ${message}`);
+				remote.disable();
+			}
+		}),
+		bindListener: async () => {
+			const webSockets = new ws.WebSocketServer({
+				noServer: true,
+				maxPayload: MAX_REQUEST_BYTES
+			});
+			const server = (0, node_http.createServer)((incoming, outgoing) => {
+				(async () => {
+					const abort = new AbortController();
+					const disconnected = () => abort.abort();
+					incoming.once("aborted", disconnected);
+					outgoing.once("close", disconnected);
+					try {
+						const url = new URL(incoming.url ?? "/", `http://${incoming.headers.host ?? "localhost"}`);
+						const headers = new Headers();
+						for (const [name, value] of Object.entries(incoming.headers)) if (value !== void 0) headers.set(name, Array.isArray(value) ? value.join(", ") : value);
+						const body = incoming.method === "GET" || incoming.method === "HEAD" ? void 0 : await readBody(incoming);
+						const request = new Request(url, {
+							method: incoming.method,
+							headers,
+							signal: abort.signal,
+							...body === void 0 ? {} : { body }
+						});
+						await writeResponse(outgoing, await app.fetch(request, {
+							listener: "tunnel",
+							incoming
+						}));
+					} finally {
+						incoming.off("aborted", disconnected);
+						outgoing.off("close", disconnected);
+					}
+				})().catch((error) => {
+					options.onNotice(`tunnel request failed: ${String(error)}`);
+					if (!outgoing.headersSent) {
+						outgoing.writeHead(500, { "content-type": "application/json" });
+						outgoing.end(JSON.stringify({ error: "The tunnel request failed." }));
+					} else outgoing.destroy();
+				});
+			});
+			server.on("upgrade", (incoming, socket, head) => {
+				const url = new URL(incoming.url ?? "/", `http://${incoming.headers.host ?? "localhost"}`);
+				const verdict = require_index$2.originVerdict({
+					listener: "tunnel",
+					method: incoming.method ?? "GET",
+					isUpgrade: true,
+					origin: incoming.headers.origin,
+					host: incoming.headers.host,
+					local: require_index$2.localOriginPolicy(0),
+					tunnel: remote.tunnelPolicy()
+				});
+				const cookies = new Map((incoming.headers.cookie ?? "").split(";").map((part) => {
+					const at = part.indexOf("=");
+					return [part.slice(0, at).trim(), part.slice(at + 1).trim()];
+				}));
+				const device = remote.authorize(cookies.get(`__Host-${require_remote.DEVICE_COOKIE}`));
+				if (require_index.isDevProxyPath(url.pathname) && verdict === "allow" && device !== void 0) {
+					const parsed = require_index.parseProxyPath(url.pathname);
+					const target = parsed.kind === "match" ? devProxy.find(parsed.name) : void 0;
+					if (parsed.kind !== "match" || target === void 0) {
+						socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
+						socket.destroy();
+						return;
+					}
+					webSockets.handleUpgrade(incoming, socket, head, (client) => {
+						const untrack = remote.trackSocket(device, (code, reason) => client.close(code, reason));
+						client.once("close", untrack);
+						require_devProxySocket.relayDevProxySocket(client, {
+							port: target.port,
+							upstreamPath: `${parsed.upstreamPath}${url.search}`,
+							protocols: incoming.headers["sec-websocket-protocol"],
+							onNotice: (message) => options.onNotice(message)
+						});
+					});
+					return;
+				}
+				const channel = device === void 0 ? void 0 : remote.channelFor(device, "protocol");
+				if (!require_packageApi.parseDoomSocketPath(url.pathname) || verdict !== "allow" || !device || !channel) {
+					socket.write("HTTP/1.1 403 Forbidden\r\n\r\n");
+					socket.destroy();
+					return;
+				}
+				webSockets.handleUpgrade(incoming, socket, head, (client) => {
+					let upstream;
+					try {
+						upstream = options.connectProtocol(url.pathname);
+					} catch (error) {
+						options.onNotice(`remote protocol could not connect: ${String(error)}`);
+						client.close(1011, "protocol unavailable");
+						return;
+					}
+					const pending = [];
+					let pendingBytes = 0;
+					let closed = false;
+					const untrack = remote.trackSocket(device, (code, reason) => client.close(code, reason));
+					const close = () => {
+						if (closed) return;
+						closed = true;
+						untrack();
+						client.close();
+						upstream.close();
+					};
+					client.on("message", (raw) => {
+						if (closed) return;
+						const bytes = Array.isArray(raw) ? Buffer.concat(raw) : Buffer.from(raw);
+						let envelope;
+						try {
+							envelope = JSON.parse(bytes.toString("utf8"));
+						} catch {
+							close();
+							return;
+						}
+						const opened = channel.open(envelope);
+						if (!opened.ok) {
+							close();
+							return;
+						}
+						const plain = Buffer.from(opened.plaintext);
+						if (upstream.readyState === ws.default.OPEN) upstream.send(plain);
+						else {
+							pendingBytes += plain.byteLength;
+							if (pendingBytes > MAX_REQUEST_BYTES) close();
+							else pending.push(plain);
+						}
+					});
+					upstream.on("open", () => {
+						for (const bytes of pending) upstream.send(bytes);
+						pending.length = 0;
+						pendingBytes = 0;
+					});
+					upstream.on("message", (raw) => {
+						if (closed) return;
+						const plain = Array.isArray(raw) ? Buffer.concat(raw) : Buffer.from(raw);
+						const sealed = channel.seal(plain);
+						if (!sealed.ok) {
+							close();
+							return;
+						}
+						client.send(Buffer.from(JSON.stringify(sealed.envelope)));
+					});
+					client.on("close", close);
+					client.on("error", close);
+					upstream.on("close", close);
+					upstream.on("error", (error) => {
+						options.onNotice(`remote protocol failed: ${error.message}`);
+						close();
+					});
+				});
+			});
+			server.headersTimeout = TUNNEL_HEADERS_TIMEOUT_MS;
+			server.requestTimeout = TUNNEL_REQUEST_TIMEOUT_MS;
+			server.maxConnections = TUNNEL_CONNECTION_LIMIT;
+			server.maxRequestsPerSocket = TUNNEL_REQUESTS_PER_SOCKET;
+			await new Promise((resolve, reject) => {
+				server.once("error", reject);
+				server.listen(0, "127.0.0.1", resolve);
+			});
+			const address = server.address();
+			if (!address || typeof address === "string") throw new Error("The tunnel listener has no TCP address.");
+			return {
+				port: address.port,
+				close: async () => {
+					for (const client of webSockets.clients) client.terminate();
+					webSockets.close();
+					server.closeAllConnections();
+					await new Promise((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+				}
+			};
+		},
+		bundleTrust: () => options.bundleTrust(),
+		onNotice: (message) => options.onNotice(message)
+	});
+	require_remoteRoutes.registerRemoteRoutes(app, {
+		remote,
+		listenerOf: (context) => context.env.listener
+	});
+	require_devProxyRoutes.registerDevProxyRoutes(app, {
+		store: devProxy,
+		listenerOf: (context) => context.env.listener,
+		reservedPorts: () => [
+			remote.tunnelPort(),
+			frontendOrigin === void 0 ? void 0 : Number(new URL(frontendOrigin).port),
+			...options.reservedPorts?.() ?? []
+		],
+		onNotice: (message) => options.onNotice(message)
+	});
+	app.post("/api/remote/frontend", async (context) => {
+		if (context.env.listener !== "local") return context.json({ error: "This action is only available on the host." }, 403);
+		if (context.req.header("x-doompi-web-registration") !== options.registrationToken) return context.json({ error: "The web presentation server was not authenticated." }, 403);
+		let body;
+		try {
+			body = await context.req.json();
+		} catch {
+			return context.json({ error: "A loopback web origin is required." }, 400);
+		}
+		const origin = typeof body === "object" && body !== null && "origin" in body ? body.origin : void 0;
+		if (typeof origin !== "string") return context.json({ error: "A loopback web origin is required." }, 400);
+		let parsed;
+		try {
+			parsed = new URL(origin);
+		} catch {
+			return context.json({ error: "The web origin is invalid." }, 400);
+		}
+		if (parsed.protocol !== "http:" || ![
+			"127.0.0.1",
+			"localhost",
+			"[::1]"
+		].includes(parsed.hostname) || parsed.pathname !== "/" || parsed.search !== "" || parsed.hash !== "" || !parsed.port) return context.json({ error: "The web origin must be a loopback HTTP listener." }, 400);
+		frontendOrigin = parsed.origin;
+		return context.json({ ok: true });
+	});
+	app.post(require_remote.REMOTE_HTTP_ROUTE, async (context) => {
+		const device = remote.authorize((0, hono_cookie.getCookie)(context, require_remote.DEVICE_COOKIE, "host"));
+		const channel = device === void 0 ? void 0 : remote.channelFor(device, "http");
+		if (!device || !channel) return context.json({ error: "A sealed paired device is required." }, 401);
+		let envelope;
+		try {
+			envelope = await context.req.json();
+		} catch {
+			return context.json({ error: "The sealed request envelope was malformed." }, 400);
+		}
+		const opened = channel.open(envelope);
+		if (!opened.ok) return context.json({ error: `The sealed request was refused: ${opened.failure}.` }, 400);
+		let decoded;
+		try {
+			decoded = JSON.parse(new TextDecoder().decode(opened.plaintext));
+		} catch {
+			return context.json({ error: "The sealed HTTP request was malformed." }, 400);
+		}
+		const inner = sealedRequest(decoded);
+		const body = decodedBody(inner?.body);
+		if (!inner || !body) return context.json({ error: "The sealed HTTP request was invalid." }, 400);
+		const target = new URL(inner.target, "http://doompi.local");
+		const headers = new Headers();
+		for (const [name, value] of inner.headers) {
+			const normalized = name.toLowerCase();
+			if (FORBIDDEN_HEADERS.has(normalized) || normalized.startsWith("sec-")) continue;
+			headers.append(name, value);
+		}
+		const action = require_index$3.stepUpActionFor(inner.method, target.pathname);
+		let stepUpDenied = false;
+		if (action && remote.stepUpRequired(action)) {
+			const assertion = headers.get(require_remote.STEP_UP_HEADER);
+			let credential;
+			try {
+				credential = assertion ? JSON.parse(Buffer.from(assertion, "base64url").toString("utf8")) : void 0;
+			} catch {
+				credential = void 0;
+			}
+			const ceremony = credential;
+			if (typeof ceremony?.ceremonyId !== "string" || !await remote.passkeys().finishStepUp(ceremony.ceremonyId, `device:${device}`, action, ceremony.response)) stepUpDenied = true;
+		}
+		headers.delete(require_remote.STEP_UP_HEADER);
+		headers.set(require_packageApi.DOOM_API_CALLER_LOCALITY_HEADER, "remote");
+		headers.set(require_packageApi.DOOM_API_CALLER_DEVICE_ID_HEADER, device);
+		headers.set(require_packageApi.DOOM_API_CALLER_STEP_UP_HEADER, action && remote.stepUpRequired(action) ? "verified" : "not-required");
+		let response;
+		if (stepUpDenied) response = context.json({
+			error: "This action needs a fresh passkey gesture.",
+			action
+		}, 401);
+		else if (require_sessionMcpRoutes.isSessionMcpHostRoute(target.pathname)) response = context.json({ error: "Session MCP management is only available on the host." }, 403);
+		else {
+			const internal = new Request(target, {
+				method: inner.method,
+				headers,
+				...inner.method === "GET" || inner.method === "HEAD" ? {} : { body }
+			});
+			if (target.pathname === "/api/remote" || target.pathname.startsWith("/api/remote/")) {
+				headers.set("cookie", context.req.header("cookie") ?? "");
+				headers.set("host", context.req.header("host") ?? "");
+				headers.set("origin", context.req.header("origin") ?? "");
+				response = await app.fetch(new Request(internal, { headers }), {
+					listener: "tunnel",
+					sealedDeviceId: device
+				});
+			} else response = await options.forward(internal);
+		}
+		const responseBody = Buffer.from(await response.arrayBuffer());
+		const sealed = channel.seal(new TextEncoder().encode(JSON.stringify({
+			v: SEALED_HTTP_VERSION,
+			status: response.status,
+			headers: [...response.headers.entries()],
+			body: responseBody.toString("base64")
+		})));
+		return sealed.ok ? context.json(sealed.envelope) : context.json({ error: `The sealed response failed: ${sealed.failure}.` }, 503);
+	});
+	app.on(["POST", "DELETE"], "*", async (context) => {
+		if (!require_sessionMcpRoutes.isPublicSessionMcpRoute(context.req.method, context.req.path) && !(context.req.method === "POST" && context.req.path === SESSION_PEER_INBOX_ROUTE) && !(context.req.method === "POST" && VOICE_PEER_ROUTES.has(context.req.path))) return context.notFound();
+		return options.forward(context.req.raw);
+	});
+	app.on(["GET", "HEAD"], "*", async (context) => {
+		if (require_sessionMcpRoutes.isPublicSessionMcpRoute(context.req.method, context.req.path)) return options.forward(context.req.raw);
+		if (context.req.path.startsWith("/api/")) return context.json({ error: "Not found." }, 404);
+		if (context.req.path === "/" && remote.authorize((0, hono_cookie.getCookie)(context, "doompi_device", "host")) === void 0) return context.redirect("/pair");
+		if (context.req.path === "/bundle-manifest.json" || context.req.path.startsWith("/bundle-assets/")) {
+			const from = new URL(context.req.url);
+			return await options.forward(new Request(new URL(`${from.pathname}${from.search}`, "http://doompi.local"), { method: context.req.method }));
+		}
+		if (!frontendOrigin) return context.json({ error: "The web presentation server is unavailable." }, 503);
+		const from = new URL(context.req.url);
+		const target = new URL(`${from.pathname}${from.search}`, frontendOrigin);
+		const result = await fetch(target, {
+			method: context.req.method,
+			redirect: "manual"
+		});
+		const headers = new Headers(result.headers);
+		headers.delete("set-cookie");
+		return new Response(result.body, {
+			status: result.status,
+			headers
+		});
+	});
+	return {
+		remote,
+		fetchLocal: async (request) => app.fetch(request, { listener: "local" }),
+		close: async () => remote.close()
+	};
+}
+//#endregion
+exports.createRemoteRuntime = createRemoteRuntime;
+
+//# sourceMappingURL=remoteRuntime.cjs.map