coderaft 0.0.15 → 0.0.18

package/README.md

@@ -45,9 +45,11 @@ npx coderaft -o .
 ### Docker
 
 ```sh
-docker run -it --rm -p 6063:6063 node:alpine npx -y coderaft
+docker run -it --rm -p 6063:6063 -v coderaft:/data ghcr.io/pithings/coderaft
 ```
 
+Based on Alpine with Node.js LTS, bash, corepack (npm/pnpm/yarn) (~65 MB download, ~89 MB final). Data persists in `/data` volume (`/data/workspace` for project files, `/data/home` symlinked to `/root` for configs).
+
 ## Programmatic
 
 ```ts
@@ -137,13 +139,13 @@ interface CodeServerHandle {
 
 ### Server
 
-| Option                        | Description                                    |
-| ----------------------------- | ---------------------------------------------- |
-| `-p, --port <port>`           | Port to listen on (default: `$PORT` or `6063`) |
-| `-H, --host <host>`           | Host/interface to bind                         |
-| `--server-base-path <path>`   | Base path for the web UI (default: `/`)        |
-| `--socket-path <path>`        | Path to a socket file to listen on             |
-| `--print-startup-performance` | Print startup timing to stdout                 |
+| Option                        | Description                                         |
+| ----------------------------- | --------------------------------------------------- |
+| `-p, --port <port>`           | Port to listen on (default: `$PORT` or `6063`)      |
+| `-H, --host <host>`           | Host/interface to bind                              |
+| `--base-url <path>`           | Base URL the server is mounted under (default: `/`) |
+| `--socket-path <path>`        | Path to a socket file to listen on                  |
+| `--print-startup-performance` | Print startup timing to stdout                      |
 
 ### Auth
 

package/android-preload.cjs

@@ -0,0 +1,54 @@
+// Android/Termux preload — injected via NODE_OPTIONS --require into all child
+// processes. VS Code strips LD_PRELOAD from forked processes, which breaks two
+// things that termux-exec normally handles:
+//   1. /proc/self/exe → process.execPath resolves to the Android linker
+//   2. execve() of Termux binaries fails with EACCES (noexec mount / SELinux)
+//
+// VS Code's bundled code also explicitly `delete env.LD_PRELOAD` from the env
+// object passed to child_process.fork/spawn, so simply restoring process.env
+// is not enough — we must monkey-patch child_process.spawn to re-inject it.
+"use strict";
+
+Object.defineProperty(process, "platform", { value: "linux" });
+
+// Fix process.execPath when termux-exec is unavailable
+const execPath = process.execPath;
+if (execPath.includes("linker64") || execPath.startsWith("/apex/")) {
+  const resolved =
+    process.env.TERMUX_EXEC__PROC_SELF_EXE || "/data/data/com.termux/files/usr/bin/node";
+  Object.defineProperty(process, "execPath", {
+    value: resolved,
+    writable: true,
+    configurable: true,
+    enumerable: true,
+  });
+}
+
+// Ensure LD_PRELOAD with termux-exec is always present in child process envs.
+// VS Code strips it via `delete env.LD_PRELOAD` before spawning children.
+// We patch child_process.spawn (which fork() calls internally) to re-inject it.
+const TERMUX_EXEC_LIB = "/data/data/com.termux/files/usr/lib/libtermux-exec.so";
+let _termuxExecExists;
+function termuxExecExists() {
+  if (_termuxExecExists === undefined) {
+    try {
+      require("fs").accessSync(TERMUX_EXEC_LIB);
+      _termuxExecExists = true;
+    } catch {
+      _termuxExecExists = false;
+    }
+  }
+  return _termuxExecExists;
+}
+
+if (termuxExecExists()) {
+  process.env.LD_PRELOAD = TERMUX_EXEC_LIB;
+  const cp = require("child_process");
+  const _spawn = cp.spawn;
+  cp.spawn = function spawn(cmd, args, opts) {
+    if (opts && typeof opts === "object" && opts.env && !opts.env.LD_PRELOAD) {
+      opts.env.LD_PRELOAD = TERMUX_EXEC_LIB;
+    }
+    return _spawn.apply(this, arguments);
+  };
+}

package/code.mjs

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 
 // Auto-updated by scripts/pack.ts
-const codeArchiveHash = "28b47fa16ea99a3f";
+const codeArchiveHash = "c2f3188affec085e";
 
 const archivePath = fileURLToPath(new URL("./code.tar.zst", import.meta.url));
 

package/dist/THIRD-PARTY-LICENSES.md

@@ -0,0 +1,58 @@
+# Licenses of Bundled Dependencies
+
+The published artifact additionally contains code with the following licenses:
+MIT
+
+# Bundled Dependencies
+
+## httpxy
+
+License: MIT
+Repository: https://github.com/unjs/httpxy
+
+> MIT License
+> 
+> Copyright (c) Pooya Parsa <pooya@pi0.io>
+> 
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+> 
+> The above copyright notice and this permission notice shall be included in all
+> copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+> SOFTWARE.
+> 
+> ----
+> 
+> Based on http-party/node-http-proxy (9b96cd7)
+> 
+> Copyright (c) 2010-2016 Charlie Robbins, Jarrett Cruger & the Contributors.
+> 
+> Permission is hereby granted, free of charge, to any person obtaining
+> a copy of this software and associated documentation files (the
+> "Software"), to deal in the Software without restriction, including
+> without limitation the rights to use, copy, modify, merge, publish,
+> distribute, sublicense, and/or sell copies of the Software, and to
+> permit persons to whom the Software is furnished to do so, subject to
+> the following conditions:
+> 
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+> NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+> LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+> OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+> WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/_chunks/_android.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/_chunks/libs/httpxy.mjs

@@ -0,0 +1,561 @@
+import http from "node:http";
+import https from "node:https";
+import http2 from "node:http2";
+import { EventEmitter } from "node:events";
+const upgradeHeader = /(^|,)\s*upgrade\s*($|,)/i;
+const defaultAgents = {
+	http: new http.Agent({
+		keepAlive: true,
+		maxSockets: 256,
+		maxFreeSockets: 64
+	}),
+	https: new https.Agent({
+		keepAlive: true,
+		maxSockets: 256,
+		maxFreeSockets: 64
+	})
+};
+const isSSL = /^https|wss/;
+const HTTP2_HEADER_BLACKLIST = [
+	":method",
+	":path",
+	":scheme",
+	":authority"
+];
+function setupOutgoing(outgoing, options, req, forward) {
+	outgoing.port = options[forward || "target"].port || (isSSL.test(options[forward || "target"].protocol ?? "http") ? 443 : 80);
+	for (const e of [
+		"host",
+		"hostname",
+		"socketPath",
+		"pfx",
+		"key",
+		"passphrase",
+		"cert",
+		"ca",
+		"ciphers",
+		"secureProtocol"
+	]) {
+		const value = options[forward || "target"][e];
+		if (value !== void 0) outgoing[e] = value;
+	}
+	outgoing.method = options.method || req.method;
+	outgoing.headers = { ...req.headers };
+	if (req.headers?.[":authority"]) outgoing.headers.host = req.headers[":authority"];
+	if (options.headers) for (const key of Object.keys(options.headers)) outgoing.headers[key] = options.headers[key];
+	if (req.httpVersionMajor > 1) for (const header of HTTP2_HEADER_BLACKLIST) delete outgoing.headers[header];
+	if (options.auth) outgoing.auth = options.auth;
+	if (options.ca) outgoing.ca = options.ca;
+	if (isSSL.test(options[forward || "target"].protocol ?? "http")) outgoing.rejectUnauthorized = options.secure === void 0 ? true : options.secure;
+	if (options.agent !== void 0) outgoing.agent = options.agent || false;
+	else if (req.httpVersionMajor > 1) outgoing.agent = false;
+	else {
+		const targetProto = options[forward || "target"].protocol ?? "http";
+		outgoing.agent = isSSL.test(targetProto) ? defaultAgents.https : defaultAgents.http;
+	}
+	outgoing.localAddress = options.localAddress;
+	if (!outgoing.agent) {
+		outgoing.headers = outgoing.headers || {};
+		if (typeof outgoing.headers.connection !== "string" || !upgradeHeader.test(outgoing.headers.connection)) outgoing.headers.connection = "close";
+	}
+	const target = options[forward || "target"];
+	const targetPath = target && options.prependPath !== false ? target.pathname || "" : "";
+	const targetSearch = target instanceof URL && options.prependPath !== false ? target.search || "" : "";
+	const reqUrl = req.url || "";
+	const qIdx = reqUrl.indexOf("?");
+	const reqPath = qIdx === -1 ? reqUrl : reqUrl.slice(0, qIdx);
+	const reqSearch = qIdx === -1 ? "" : reqUrl.slice(qIdx);
+	const normalizedPath = reqPath ? reqPath[0] === "/" ? reqPath : "/" + reqPath : "/";
+	let outgoingPath = options.toProxy ? "/" + reqUrl : normalizedPath + reqSearch;
+	outgoingPath = options.ignorePath ? "" : outgoingPath;
+	let fullPath = joinURL(targetPath, outgoingPath);
+	if (targetSearch) fullPath = fullPath.includes("?") ? fullPath.replace("?", targetSearch + "&") : fullPath + targetSearch;
+	outgoing.path = fullPath;
+	if (options.changeOrigin) outgoing.headers.host = requiresPort(outgoing.port, options[forward || "target"].protocol) && !hasPort(outgoing.host) ? outgoing.host + ":" + outgoing.port : outgoing.host ?? void 0;
+	return outgoing;
+}
+function joinURL(base, path) {
+	if (!base || base === "/") return path || "/";
+	if (!path || path === "/") return base || "/";
+	const baseHasTrailing = base[base.length - 1] === "/";
+	const pathHasLeading = path[0] === "/";
+	if (baseHasTrailing && pathHasLeading) return base + path.slice(1);
+	if (!baseHasTrailing && !pathHasLeading) return base + "/" + path;
+	return base + path;
+}
+function setupSocket(socket) {
+	socket.setTimeout(0);
+	socket.setNoDelay(true);
+	socket.setKeepAlive(true, 0);
+	return socket;
+}
+function getPort(req) {
+	const hostHeader = req.headers[":authority"] || req.headers.host;
+	const res = hostHeader ? hostHeader.match(/:(\d+)/) : "";
+	if (res) return res[1];
+	return hasEncryptedConnection(req) ? "443" : "80";
+}
+function hasEncryptedConnection(req) {
+	const socket = req.socket;
+	return !!socket && "encrypted" in socket && socket.encrypted;
+}
+function rewriteCookieProperty(header, config, property) {
+	if (Array.isArray(header)) return header.map(function(headerElement) {
+		return rewriteCookieProperty(headerElement, config, property);
+	});
+	return header.replace(new RegExp(String.raw`(;\s*` + property + "=)([^;]+)", "i"), function(match, prefix, previousValue) {
+		let newValue;
+		if (previousValue in config) newValue = config[previousValue];
+		else if ("*" in config) newValue = config["*"];
+		else return match;
+		return newValue ? prefix + newValue : "";
+	});
+}
+function hasPort(host) {
+	return host ? !!~host.indexOf(":") : false;
+}
+function requiresPort(_port, _protocol) {
+	const protocol = _protocol?.split(":")[0];
+	const port = +_port;
+	if (!port) return false;
+	switch (protocol) {
+		case "http":
+		case "ws": return port !== 80;
+		case "https":
+		case "wss": return port !== 443;
+		case "ftp": return port !== 21;
+		case "gopher": return port !== 70;
+		case "file": return false;
+	}
+	return port !== 0;
+}
+function defineProxyMiddleware(m) {
+	return m;
+}
+function defineProxyOutgoingMiddleware(m) {
+	return m;
+}
+const redirectRegex = /^201|30([12378])$/;
+const webOutgoingMiddleware = [
+	defineProxyOutgoingMiddleware((req, res, proxyRes) => {
+		if (req.httpVersion === "1.0" || req.httpVersionMajor >= 2 || proxyRes.statusCode === 204 || proxyRes.statusCode === 304) delete proxyRes.headers["transfer-encoding"];
+	}),
+	defineProxyOutgoingMiddleware((req, res, proxyRes) => {
+		if (req.httpVersion === "1.0") proxyRes.headers.connection = req.headers.connection || "close";
+		else if (req.httpVersionMajor < 2 && !proxyRes.headers.connection) proxyRes.headers.connection = req.headers.connection || "keep-alive";
+		else if (req.httpVersionMajor >= 2) delete proxyRes.headers.connection;
+	}),
+	defineProxyOutgoingMiddleware((req, res, proxyRes, options) => {
+		if ((options.hostRewrite || options.autoRewrite || options.protocolRewrite) && proxyRes.headers.location && redirectRegex.test(String(proxyRes.statusCode))) {
+			const target = _toURL(options.target);
+			const u = new URL(proxyRes.headers.location, target);
+			if (target.host !== u.host) return;
+			if (options.hostRewrite) u.host = options.hostRewrite;
+			else if (options.autoRewrite) {
+				if (req.headers[":authority"]) u.host = req.headers[":authority"];
+				else if (req.headers.host) u.host = req.headers.host;
+			}
+			if (options.protocolRewrite) u.protocol = options.protocolRewrite;
+			proxyRes.headers.location = u.toString();
+		}
+	}),
+	defineProxyOutgoingMiddleware((req, res, proxyRes, options) => {
+		const rewriteCookieDomainConfig = typeof options.cookieDomainRewrite === "string" ? { "*": options.cookieDomainRewrite } : options.cookieDomainRewrite;
+		const rewriteCookiePathConfig = typeof options.cookiePathRewrite === "string" ? { "*": options.cookiePathRewrite } : options.cookiePathRewrite;
+		const preserveHeaderKeyCase = options.preserveHeaderKeyCase;
+		let rawHeaderKeyMap;
+		const setHeader = function(key, header) {
+			if (header === void 0 || !String(key).trim()) return;
+			if (rewriteCookieDomainConfig && key.toLowerCase() === "set-cookie") header = rewriteCookieProperty(header, rewriteCookieDomainConfig, "domain");
+			if (rewriteCookiePathConfig && key.toLowerCase() === "set-cookie") header = rewriteCookieProperty(header, rewriteCookiePathConfig, "path");
+			try {
+				res.setHeader(String(key).trim(), header);
+			} catch {}
+		};
+		if (preserveHeaderKeyCase && proxyRes.rawHeaders !== void 0) {
+			rawHeaderKeyMap = {};
+			for (let i = 0; i < proxyRes.rawHeaders.length; i += 2) {
+				const key = proxyRes.rawHeaders[i];
+				rawHeaderKeyMap[key.toLowerCase()] = key;
+			}
+		}
+		for (let key of Object.keys(proxyRes.headers)) {
+			const header = proxyRes.headers[key];
+			if (preserveHeaderKeyCase && rawHeaderKeyMap) key = rawHeaderKeyMap[key] || key;
+			setHeader(key, header);
+		}
+	}),
+	defineProxyOutgoingMiddleware((req, res, proxyRes) => {
+		res.statusCode = proxyRes.statusCode;
+		if (proxyRes.statusMessage && req.httpVersionMajor < 2) res.statusMessage = proxyRes.statusMessage;
+	})
+];
+function _toURL(target) {
+	if (target instanceof URL) return target;
+	if (typeof target === "string") return new URL(target);
+	const protocol = target.protocol || "http:";
+	const host = target.host || target.hostname || "localhost";
+	const port = target.port;
+	return new URL(`${protocol}//${host}${port ? ":" + port : ""}`);
+}
+const nativeAgents = {
+	http,
+	https
+};
+const redirectStatuses = new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+const webIncomingMiddleware = [
+	defineProxyMiddleware((req) => {
+		if ((req.method === "DELETE" || req.method === "OPTIONS") && !req.headers["content-length"]) {
+			req.headers["content-length"] = "0";
+			delete req.headers["transfer-encoding"];
+		}
+	}),
+	defineProxyMiddleware((req, res, options) => {
+		if (options.timeout) req.socket.setTimeout(options.timeout, () => {
+			req.socket.destroy();
+		});
+	}),
+	defineProxyMiddleware((req, res, options) => {
+		if (!options.xfwd) return;
+		const encrypted = req.isSpdy || hasEncryptedConnection(req);
+		const values = {
+			for: req.connection.remoteAddress || req.socket.remoteAddress,
+			port: getPort(req),
+			proto: encrypted ? "https" : "http"
+		};
+		for (const header of [
+			"for",
+			"port",
+			"proto"
+		]) {
+			const key = "x-forwarded-" + header;
+			if (!req.headers[key]) req.headers[key] = values[header];
+		}
+		req.headers["x-forwarded-host"] = req.headers["x-forwarded-host"] || req.headers[":authority"] || req.headers.host || "";
+	}),
+	defineProxyMiddleware((req, res, options, server, head, callback) => {
+		server.emit("start", req, res, options.target || options.forward);
+		const http = nativeAgents.http;
+		const https = nativeAgents.https;
+		const maxRedirects = typeof options.followRedirects === "number" ? options.followRedirects : options.followRedirects ? 5 : 0;
+		if (options.forward) {
+			const forwardReq = (isSSL.test(options.forward.protocol || "http") ? https : http).request(setupOutgoing(options.ssl || {}, options, req, "forward"));
+			const forwardError = createErrorHandler(forwardReq, options.forward);
+			req.on("error", forwardError);
+			forwardReq.on("error", forwardError);
+			(options.buffer || req).pipe(forwardReq);
+			if (!options.target) {
+				res.end();
+				return;
+			}
+		}
+		const proxyReq = (isSSL.test(options.target.protocol || "http") ? https : http).request(setupOutgoing(options.ssl || {}, options, req));
+		proxyReq.on("socket", (_socket) => {
+			if (server && !proxyReq.getHeader("expect")) server.emit("proxyReq", proxyReq, req, res, options);
+		});
+		if (options.proxyTimeout) proxyReq.setTimeout(options.proxyTimeout, function() {
+			proxyReq.destroy();
+		});
+		res.on("close", function() {
+			if (!res.writableFinished) proxyReq.destroy();
+		});
+		const proxyError = createErrorHandler(proxyReq, options.target);
+		req.on("error", proxyError);
+		proxyReq.on("error", proxyError);
+		function createErrorHandler(proxyReq, url) {
+			return function proxyError(err) {
+				if (!req.socket?.writable && err.code === "ECONNRESET") {
+					server.emit("econnreset", err, req, res, url);
+					return proxyReq.destroy();
+				}
+				if (callback) callback(err, req, res, url);
+				else server.emit("error", err, req, res, url);
+			};
+		}
+		let bodyBuffer;
+		if (maxRedirects > 0) {
+			const chunks = [];
+			const source = options.buffer || req;
+			source.on("data", (chunk) => {
+				chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+				proxyReq.write(chunk);
+			});
+			source.on("end", () => {
+				bodyBuffer = Buffer.concat(chunks);
+				proxyReq.end();
+			});
+			source.on("error", (err) => {
+				proxyReq.destroy(err);
+			});
+		} else proxyReq.on("socket", (socket) => {
+			if (socket.pending) socket.on("connect", () => (options.buffer || req).pipe(proxyReq));
+			else (options.buffer || req).pipe(proxyReq);
+		});
+		function handleResponse(proxyRes, redirectCount, currentUrl) {
+			const statusCode = proxyRes.statusCode;
+			if (maxRedirects > 0 && redirectStatuses.has(statusCode) && redirectCount < maxRedirects && proxyRes.headers.location) {
+				proxyRes.resume();
+				const location = new URL(proxyRes.headers.location, currentUrl);
+				const preserveMethod = statusCode === 307 || statusCode === 308;
+				const redirectMethod = preserveMethod ? req.method || "GET" : "GET";
+				const isHTTPS = isSSL.test(location.protocol);
+				const agent = isHTTPS ? https : http;
+				const redirectHeaders = { ...req.headers };
+				if (options.headers) Object.assign(redirectHeaders, options.headers);
+				redirectHeaders.host = location.host;
+				if (location.host !== currentUrl.host) {
+					delete redirectHeaders.authorization;
+					delete redirectHeaders.cookie;
+				}
+				if (!preserveMethod) {
+					delete redirectHeaders["content-length"];
+					delete redirectHeaders["content-type"];
+					delete redirectHeaders["transfer-encoding"];
+				}
+				const redirectOpts = {
+					hostname: location.hostname,
+					port: location.port || (isHTTPS ? 443 : 80),
+					path: location.pathname + location.search,
+					method: redirectMethod,
+					headers: redirectHeaders,
+					agent: options.agent || false
+				};
+				if (isHTTPS) redirectOpts.rejectUnauthorized = options.secure === void 0 ? true : options.secure;
+				const redirectReq = agent.request(redirectOpts);
+				if (server && !redirectReq.getHeader("expect")) server.emit("proxyReq", redirectReq, req, res, options);
+				if (options.proxyTimeout) redirectReq.setTimeout(options.proxyTimeout, () => {
+					redirectReq.destroy();
+				});
+				const redirectError = createErrorHandler(redirectReq, location);
+				redirectReq.on("error", redirectError);
+				redirectReq.on("response", (nextRes) => {
+					handleResponse(nextRes, redirectCount + 1, location);
+				});
+				if (preserveMethod && bodyBuffer && bodyBuffer.length > 0) redirectReq.end(bodyBuffer);
+				else redirectReq.end();
+				return;
+			}
+			if (server) server.emit("proxyRes", proxyRes, req, res);
+			if (!res.headersSent && !options.selfHandleResponse) {
+				for (const pass of webOutgoingMiddleware) if (pass(req, res, proxyRes, options)) break;
+			}
+			if (res.finished) {
+				if (server) server.emit("end", req, res, proxyRes);
+			} else {
+				res.on("close", function() {
+					proxyRes.destroy();
+				});
+				proxyRes.on("close", function() {
+					if (!proxyRes.complete && !res.destroyed) res.destroy();
+				});
+				proxyRes.on("error", function(err) {
+					if (!res.destroyed) res.destroy(err);
+					if (server.listenerCount("error") > 0) server.emit("error", err, req, res, currentUrl);
+				});
+				proxyRes.on("end", function() {
+					if (server) server.emit("end", req, res, proxyRes);
+				});
+				if (!options.selfHandleResponse) proxyRes.pipe(res);
+			}
+		}
+		proxyReq.on("response", function(proxyRes) {
+			handleResponse(proxyRes, 0, options.target);
+		});
+	})
+];
+const websocketIncomingMiddleware = [
+	defineProxyMiddleware((req, socket) => {
+		if (req.method !== "GET" || !req.headers.upgrade) {
+			socket.destroy();
+			return true;
+		}
+		if (req.headers.upgrade.toLowerCase() !== "websocket") {
+			socket.destroy();
+			return true;
+		}
+	}),
+	defineProxyMiddleware((req, socket, options) => {
+		if (!options.xfwd) return;
+		const values = {
+			for: req.connection.remoteAddress || req.socket.remoteAddress,
+			port: getPort(req),
+			proto: hasEncryptedConnection(req) ? "wss" : "ws"
+		};
+		for (const header of [
+			"for",
+			"port",
+			"proto"
+		]) {
+			const key = "x-forwarded-" + header;
+			if (!req.headers[key]) req.headers[key] = values[header];
+		}
+	}),
+	defineProxyMiddleware((req, socket, options, server, head, callback) => {
+		const createHttpHeader = function(line, headers) {
+			return Object.keys(headers).reduce(function(head, key) {
+				const value = headers[key];
+				if (!Array.isArray(value)) {
+					head.push(key + ": " + value);
+					return head;
+				}
+				for (const element of value) head.push(key + ": " + element);
+				return head;
+			}, [line]).join("\r\n") + "\r\n\r\n";
+		};
+		setupSocket(socket);
+		if (head && head.length > 0) socket.unshift(head);
+		socket.on("error", onSocketError);
+		const proxyReq = (isSSL.test(options.target.protocol || "http") ? https : http).request(setupOutgoing(options.ssl || {}, options, req));
+		if (server) server.emit("proxyReqWs", proxyReq, req, socket, options, head);
+		proxyReq.on("error", onOutgoingError);
+		proxyReq.on("response", function(res) {
+			if (!res.upgrade) if (!socket.destroyed && socket.writable) {
+				socket.write(createHttpHeader("HTTP/" + res.httpVersion + " " + res.statusCode + " " + res.statusMessage, res.headers));
+				res.on("error", onOutgoingError);
+				res.pipe(socket);
+			} else res.resume();
+		});
+		proxyReq.on("upgrade", function(proxyRes, proxySocket, proxyHead) {
+			proxySocket.on("error", onOutgoingError);
+			proxySocket.on("end", function() {
+				server.emit("close", proxyRes, proxySocket, proxyHead);
+			});
+			socket.removeListener("error", onSocketError);
+			socket.on("error", function() {
+				proxySocket.end();
+			});
+			setupSocket(proxySocket);
+			if (proxyHead && proxyHead.length > 0) proxySocket.unshift(proxyHead);
+			socket.write(createHttpHeader("HTTP/1.1 101 Switching Protocols", proxyRes.headers));
+			proxySocket.pipe(socket).pipe(proxySocket);
+			server.emit("open", proxySocket);
+			server.emit("proxySocket", proxySocket);
+		});
+		proxyReq.end();
+		function onSocketError(err) {
+			if (callback) callback(err, req, socket);
+			else server.emit("error", err, req, socket);
+			proxyReq.destroy();
+		}
+		function onOutgoingError(err) {
+			if (callback) callback(err, req, socket);
+			else server.emit("error", err, req, socket);
+			socket.end();
+		}
+	})
+];
+var ProxyServer = class extends EventEmitter {
+	_server;
+	_webPasses = [...webIncomingMiddleware];
+	_wsPasses = [...websocketIncomingMiddleware];
+	options;
+	web;
+	ws;
+	constructor(options = {}) {
+		super();
+		this.options = options || {};
+		this.options.prependPath = options.prependPath !== false;
+		this.web = _createProxyFn("web", this);
+		this.ws = _createProxyFn("ws", this);
+	}
+	listen(port, hostname) {
+		const closure = (req, res) => {
+			return this.web(req, res);
+		};
+		if (this.options.http2) {
+			if (!this.options.ssl) throw new Error("HTTP/2 requires ssl option");
+			this._server = http2.createSecureServer({
+				...this.options.ssl,
+				allowHTTP1: true
+			}, closure);
+		} else if (this.options.ssl) this._server = https.createServer(this.options.ssl, closure);
+		else this._server = http.createServer(closure);
+		if (this.options.ws) this._server.on("upgrade", (req, socket, head) => {
+			this.ws(req, socket, this.options, head).catch(() => {});
+		});
+		this._server.listen(port, hostname);
+		return this;
+	}
+	close(callback) {
+		if (this._server) this._server.close((...args) => {
+			this._server = void 0;
+			if (callback) Reflect.apply(callback, void 0, args);
+		});
+	}
+	before(type, passName, pass) {
+		if (type !== "ws" && type !== "web") throw new Error("type must be `web` or `ws`");
+		const passes = this._getPasses(type);
+		let i = false;
+		for (const [idx, v] of passes.entries()) if (v.name === passName) i = idx;
+		if (i === false) throw new Error("No such pass");
+		passes.splice(i, 0, pass);
+	}
+	after(type, passName, pass) {
+		if (type !== "ws" && type !== "web") throw new Error("type must be `web` or `ws`");
+		const passes = this._getPasses(type);
+		let i = false;
+		for (const [idx, v] of passes.entries()) if (v.name === passName) i = idx;
+		if (i === false) throw new Error("No such pass");
+		passes.splice(i++, 0, pass);
+	}
+	_getPasses(type) {
+		return type === "ws" ? this._wsPasses : this._webPasses;
+	}
+};
+function createProxyServer(options = {}) {
+	return new ProxyServer(options);
+}
+function _createProxyFn(type, server) {
+	return function(req, res, opts, head) {
+		const requestOptions = {
+			...opts,
+			...server.options
+		};
+		for (const key of ["target", "forward"]) if (typeof requestOptions[key] === "string") requestOptions[key] = new URL(requestOptions[key]);
+		if (!requestOptions.target && !requestOptions.forward) {
+			this.emit("error", /* @__PURE__ */ new Error("Must provide a proper URL as target"));
+			return Promise.resolve();
+		}
+		let _resolve;
+		let _reject;
+		const callbackPromise = new Promise((resolve, reject) => {
+			_resolve = resolve;
+			_reject = reject;
+		});
+		res.on("close", () => {
+			_resolve();
+		});
+		res.on("error", (error) => {
+			_reject(error);
+		});
+		for (const pass of server._getPasses(type)) {
+			let stop;
+			try {
+				stop = pass(req, res, requestOptions, server, head, (error) => {
+					if (server.listenerCount("error") > 0) {
+						server.emit("error", error, req, res);
+						_resolve();
+					} else _reject(error);
+				});
+			} catch (error) {
+				if (server.listenerCount("error") > 0) {
+					server.emit("error", error, req, res);
+					_resolve();
+				} else _reject(error);
+				break;
+			}
+			if (stop) {
+				_resolve();
+				break;
+			}
+		}
+		return callbackPromise;
+	};
+}
+export { createProxyServer as t };

package/dist/_chunks/rolldown-runtime.mjs

@@ -0,0 +1,3 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+export { __require as t };

package/dist/_chunks/server.mjs

@@ -1,11 +1,88 @@
-import { createRequire } from "node:module";
-import { randomBytes, randomUUID } from "node:crypto";
+import { t as __require } from "./rolldown-runtime.mjs";
+import { t as createProxyServer } from "./libs/httpxy.mjs";
+import { fileURLToPath } from "node:url";
 import { createReadStream, readFileSync, readdirSync, unlinkSync } from "node:fs";
+import { randomBytes, randomUUID } from "node:crypto";
 import { createServer } from "node:http";
 import { extname, join, normalize, sep } from "node:path";
 import { stat } from "node:fs/promises";
 import { loadCode } from "#code";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
+if (process.platform === "android") {
+	Object.defineProperty(process, "platform", { value: "linux" });
+	if (process.execPath.includes("linker64") || process.execPath.startsWith("/apex/")) {
+		const resolved = process.env.TERMUX_EXEC__PROC_SELF_EXE || "/data/data/com.termux/files/usr/bin/node";
+		Object.defineProperty(process, "execPath", {
+			value: resolved,
+			writable: true,
+			configurable: true,
+			enumerable: true
+		});
+	}
+	const preload = `--require "${fileURLToPath(import.meta.resolve("#android-preload"))}"`;
+	process.env.NODE_OPTIONS = process.env.NODE_OPTIONS ? `${process.env.NODE_OPTIONS} ${preload}` : preload;
+	const _fs = process.getBuiltinModule?.("fs") ?? __require("node:fs");
+	const { syncBuiltinESMExports: _syncESM } = process.getBuiltinModule?.("module") ?? __require("node:module");
+	const TERMUX_EXEC_LIB = "/data/data/com.termux/files/usr/lib/libtermux-exec.so";
+	try {
+		_fs.accessSync(TERMUX_EXEC_LIB);
+		const _cp = process.getBuiltinModule?.("child_process") ?? __require("node:child_process");
+		const _injectLdPreload = (opts) => {
+			if (opts && typeof opts === "object" && opts.env) {
+				const env = opts.env;
+				if (!env.LD_PRELOAD) env.LD_PRELOAD = TERMUX_EXEC_LIB;
+			}
+		};
+		const _spawn = _cp.spawn;
+		_cp.spawn = function spawn(...spawnArgs) {
+			_injectLdPreload(spawnArgs[2]);
+			return _spawn.apply(this, spawnArgs);
+		};
+		const _fork = _cp.fork;
+		_cp.fork = function fork(modulePath, ...rest) {
+			for (const arg of rest) if (arg && typeof arg === "object" && !Array.isArray(arg)) {
+				_injectLdPreload(arg);
+				break;
+			}
+			return _fork.call(this, modulePath, ...rest);
+		};
+		_syncESM();
+	} catch {}
+	if (process.env.PATH) {
+		const accessible = process.env.PATH.split(":").filter((dir) => {
+			try {
+				_fs.accessSync(dir, _fs.constants.R_OK);
+				return true;
+			} catch {
+				return false;
+			}
+		});
+		if (accessible.length > 0) process.env.PATH = accessible.join(":");
+	}
+	const _os = process.getBuiltinModule?.("os") ?? __require("node:os");
+	const _crypto = process.getBuiltinModule?.("crypto") ?? __require("node:crypto");
+	const BLACKLISTED = new Set([
+		"00:00:00:00:00:00",
+		"ff:ff:ff:ff:ff:ff",
+		"ac:de:48:00:11:22"
+	]);
+	const original = _os.networkInterfaces;
+	_os.networkInterfaces = function networkInterfaces() {
+		const ifaces = original.call(_os);
+		for (const name in ifaces) for (const info of ifaces[name]) if (info.mac && !BLACKLISTED.has(info.mac)) return ifaces;
+		const hash = _crypto.createHash("md5").update(_os.hostname()).digest();
+		hash[0] = (hash[0] | 2) & 254;
+		ifaces._coderaft = [{
+			address: "10.0.0.1",
+			netmask: "255.255.255.0",
+			family: "IPv4",
+			mac: [...hash.subarray(0, 6)].map((b) => b.toString(16).padStart(2, "0")).join(":"),
+			internal: false,
+			cidr: "10.0.0.1/24"
+		}];
+		return ifaces;
+	};
+	_syncESM();
+}
 const STATIC_MIME = {
 	".js": "text/javascript",
 	".mjs": "text/javascript",
@@ -47,12 +124,7 @@ async function serveStatic(res, root, relPath) {
 		return false;
 	}
 }
-if (process.platform === "android") {
-	Object.defineProperty(process, "platform", { value: "linux" });
-	const preload = `--import "data:text/javascript,Object.defineProperty(process,'platform',{value:'linux'})"`;
-	process.env.NODE_OPTIONS = process.env.NODE_OPTIONS ? `${process.env.NODE_OPTIONS} ${preload}` : preload;
-}
-const _os = __require("node:os");
+const _os = process.getBuiltinModule?.("os") ?? __require("node:os");
 const MANIFEST_BODY = JSON.stringify({
 	name: "coderaft",
 	short_name: "coderaft",
@@ -79,12 +151,13 @@ async function createCodeServer(opts = {}) {
 	const withoutToken = opts.vscode?.["without-connection-token"] === true || !explicitToken && isLocal;
 	const connectionToken = withoutToken ? "" : opts.connectionToken ?? randomUUID();
 	const defaultFolder = opts.defaultFolder ?? process.cwd();
+	const baseURL = normalizeBaseURL(opts.baseURL ?? opts.vscode?.["server-base-path"]);
 	const mintKey = randomBytes(32);
 	process.env.CODE_SERVER_PARENT_PID ??= String(process.pid);
 	cleanupStaleLocks(opts.vscode?.["user-data-dir"] ?? join(_os.homedir(), ".vscode-server-oss", "data"));
+	watchChildProcessHealth();
 	const { modulesDir } = await loadCode();
 	const vsRootPath = join(modulesDir, "code-server", "lib", "vscode");
-	ensureNetworkInterface();
 	const _log = console.log;
 	console.log = (...args) => {
 		if (typeof args[0] === "string" && args[0].includes("[reconnection-grace-time]")) return;
@@ -100,17 +173,26 @@ async function createCodeServer(opts = {}) {
 	}
 	const vscodeServer = await (await mod.loadCodeWithNls()).createServer(null, {
 		"default-folder": defaultFolder,
+		...baseURL ? { "server-base-path": baseURL } : {},
 		...withoutToken ? { "without-connection-token": true } : { "connection-token": connectionToken },
-		"reconnection-grace-time": "10800",
+		"reconnection-grace-time": "30",
 		"disable-getting-started-override": true,
 		...opts.vscode
 	});
 	console.log = _log;
+	const proxy = createProxyServer({});
+	proxy.on("error", (err, req, res) => {
+		if (res && "writeHead" in res) {
+			res.writeHead(502, { "Content-Type": "text/plain" });
+			res.end(`Proxy error: ${err.message}`);
+		}
+	});
 	return {
 		connectionToken,
 		handleRequest(req, res) {
 			const method = req.method ?? "GET";
-			const url = (req.url ?? "/").split("?")[0];
+			const strippedUrl = stripBaseURL(req.url ?? "/", baseURL);
+			const url = strippedUrl.split("?")[0];
 			if (url === "/manifest.json") {
 				res.writeHead(200, {
 					"Content-Type": "application/manifest+json",
@@ -153,7 +235,7 @@ async function createCodeServer(opts = {}) {
 				return;
 			}
 			if (url === "/login" || url === "/logout") {
-				res.writeHead(302, { Location: "/" });
+				res.writeHead(302, { Location: `${baseURL}/` });
 				res.end();
 				return;
 			}
@@ -163,11 +245,30 @@ async function createCodeServer(opts = {}) {
 				});
 				return;
 			}
+			const proxyMatch = parseProxyPath(strippedUrl);
+			if (proxyMatch) {
+				const { port: targetPort, path: targetPath } = proxyMatch;
+				proxy.web(req, res, {
+					target: `http://127.0.0.1:${targetPort}${targetPath}`,
+					ignorePath: true,
+					xfwd: true
+				});
+				return;
+			}
 			vscodeServer.handleRequest(req, res);
 		},
-		handleUpgrade(req, socket) {
-			vscodeServer.handleUpgrade(req, socket);
-			socket.resume();
+		handleUpgrade(req, socket, _head) {
+			const proxyMatch = parseProxyPath(stripBaseURL(req.url ?? "/", baseURL));
+			if (proxyMatch) {
+				const { port: targetPort, path: targetPath } = proxyMatch;
+				proxy.ws(req, socket, {
+					target: `http://127.0.0.1:${targetPort}${targetPath}`,
+					ignorePath: true,
+					xfwd: true
+				}, _head);
+				return;
+			}
+			vscodeServer.handleUpgrade(req, socket, _head);
 		},
 		async dispose() {
 			vscodeServer.dispose();
@@ -175,15 +276,16 @@ async function createCodeServer(opts = {}) {
 	};
 }
 async function startCodeServer(opts = {}) {
+	const socketPath = opts.socketPath;
 	const port = opts.port ?? (Number(process.env.PORT) || 6063);
 	const handler = await createCodeServer(opts);
 	const server = createServer((req, res) => {
 		handler.handleRequest(req, res);
 	});
-	server.on("upgrade", (req, socket) => {
-		handler.handleUpgrade(req, socket);
+	server.on("upgrade", (req, socket, head) => {
+		handler.handleUpgrade(req, socket, head);
 	});
-	const listen = (p) => new Promise((resolve, reject) => {
+	const listenTcp = (p) => new Promise((resolve, reject) => {
 		server.once("error", reject);
 		const cb = () => {
 			server.removeListener("error", reject);
@@ -192,17 +294,31 @@ async function startCodeServer(opts = {}) {
 		if (opts.host) server.listen(p, opts.host, cb);
 		else server.listen(p, cb);
 	});
-	try {
-		await listen(port);
+	const listenSocket = (path) => new Promise((resolve, reject) => {
+		try {
+			unlinkSync(path);
+		} catch {}
+		server.once("error", reject);
+		server.listen(path, () => {
+			server.removeListener("error", reject);
+			resolve();
+		});
+	});
+	if (socketPath) await listenSocket(socketPath);
+	else try {
+		await listenTcp(port);
 	} catch (err) {
-		if (err?.code === "EADDRINUSE") await listen(0);
+		if (err?.code === "EADDRINUSE") await listenTcp(0);
 		else throw err;
 	}
-	const actualPort = server.address().port;
+	const address = server.address();
+	const actualPort = address && typeof address === "object" && "port" in address ? address.port : void 0;
+	const basePath = normalizeBaseURL(opts.baseURL ?? opts.vscode?.["server-base-path"]);
 	return {
 		server,
 		port: actualPort,
-		url: handler.connectionToken ? `http://localhost:${actualPort}/?tkn=${handler.connectionToken}` : `http://localhost:${actualPort}/`,
+		socketPath,
+		url: socketPath ? `unix:${socketPath}` : handler.connectionToken ? `http://localhost:${actualPort}${basePath}/?tkn=${handler.connectionToken}` : `http://localhost:${actualPort}${basePath}/`,
 		connectionToken: handler.connectionToken,
 		async close() {
 			await handler.dispose();
@@ -210,33 +326,12 @@ async function startCodeServer(opts = {}) {
 			await new Promise((resolve, reject) => {
 				server.close((err) => err ? reject(err) : resolve());
 			});
+			if (socketPath) try {
+				unlinkSync(socketPath);
+			} catch {}
 		}
 	};
 }
-function ensureNetworkInterface() {
-	const original = _os.networkInterfaces;
-	const BLACKLISTED = new Set([
-		"00:00:00:00:00:00",
-		"ff:ff:ff:ff:ff:ff",
-		"ac:de:48:00:11:22"
-	]);
-	_os.networkInterfaces = function networkInterfaces() {
-		const ifaces = original.call(_os);
-		for (const name in ifaces) for (const info of ifaces[name]) if (info.mac && !BLACKLISTED.has(info.mac)) return ifaces;
-		const { createHash } = __require("node:crypto");
-		const hash = createHash("md5").update(_os.hostname()).digest();
-		hash[0] = (hash[0] | 2) & 254;
-		ifaces._coderaft = [{
-			address: "10.0.0.1",
-			netmask: "255.255.255.0",
-			family: "IPv4",
-			mac: [...hash.subarray(0, 6)].map((b) => b.toString(16).padStart(2, "0")).join(":"),
-			internal: false,
-			cidr: "10.0.0.1/24"
-		}];
-		return ifaces;
-	};
-}
 function cleanupStaleLocks(userDataDir) {
 	const storageDir = join(userDataDir, "User", "workspaceStorage");
 	try {
@@ -244,10 +339,65 @@ function cleanupStaleLocks(userDataDir) {
 			const lockPath = join(storageDir, entry, "vscode.lock");
 			try {
 				unlinkSync(lockPath);
+				console.log(`[coderaft] Removed stale lock: ${lockPath}`);
 			} catch {}
 		}
 	} catch {}
 }
+function watchChildProcessHealth() {
+	if (process.platform !== "linux" && process.platform !== "android") return;
+	const stuckCounts = /* @__PURE__ */ new Map();
+	const interval = setInterval(() => {
+		try {
+			for (const pid of readdirSync("/proc").filter((d) => /^\d+$/.test(d))) {
+				let cmdline;
+				try {
+					cmdline = readFileSync(`/proc/${pid}/cmdline`, "utf8");
+				} catch {
+					continue;
+				}
+				if (!cmdline.includes("extensionHost")) continue;
+				try {
+					const wchan = readFileSync(`/proc/${pid}/task/${pid}/wchan`, "utf8").trim();
+					if (wchan === "__futex_wait") {
+						const count = (stuckCounts.get(+pid) ?? 0) + 1;
+						stuckCounts.set(+pid, count);
+						if (count === 3) console.error(`[coderaft] Extension host (pid ${pid}) main thread stuck in ${wchan} for ${count * 5}s`);
+					} else stuckCounts.delete(+pid);
+				} catch {}
+			}
+		} catch {}
+	}, 5e3);
+	interval.unref();
+	return interval;
+}
+const PROXY_RE = /^\/proxy\/(\d+)(\/.*)?$/;
+function parseProxyPath(url) {
+	const qIdx = url.indexOf("?");
+	const pathname = qIdx === -1 ? url : url.slice(0, qIdx);
+	const query = qIdx === -1 ? "" : url.slice(qIdx);
+	const match = PROXY_RE.exec(pathname);
+	if (!match) return;
+	const port = Number(match[1]);
+	if (port < 1 || port > 65535) return;
+	return {
+		port,
+		path: (match[2] || "/") + query
+	};
+}
+function normalizeBaseURL(input) {
+	if (!input || input === "/") return "";
+	let result = input.trim();
+	if (!result.startsWith("/")) result = "/" + result;
+	while (result.endsWith("/")) result = result.slice(0, -1);
+	return result;
+}
+function stripBaseURL(url, baseURL) {
+	if (!baseURL) return url;
+	if (url === baseURL) return "/";
+	if (url.startsWith(baseURL + "/") || url.startsWith(baseURL + "?")) return url.slice(baseURL.length) || "/";
+	return url;
+}
 function sendJson(res, status, body) {
 	const payload = JSON.stringify(body);
 	res.writeHead(status, {

package/dist/cli.mjs

@@ -12,6 +12,7 @@ const { values, positionals } = parseArgs({
 			type: "string",
 			short: "H"
 		},
+		"base-url": { type: "string" },
 		"server-base-path": { type: "string" },
 		"socket-path": { type: "string" },
 		"print-startup-performance": { type: "boolean" },
@@ -92,7 +93,7 @@ if (values.help) {
   Server:
     -p, --port <port>                    Port to listen on (default: $PORT or 6063)
     -H, --host <host>                    Host/interface to bind
-        --server-base-path <path>        Base path for the web UI (default: /)
+        --base-url <path>                Base URL the server is mounted under (default: /)
         --socket-path <path>             Path to a socket file to listen on
         --print-startup-performance      Print startup timing to stdout
 
@@ -175,7 +176,6 @@ if (values.help) {
 const vscode = {};
 for (const key of [
 	"server-base-path",
-	"socket-path",
 	"print-startup-performance",
 	"connection-token-file",
 	"without-connection-token",
@@ -224,9 +224,22 @@ for (const key of [
 if (values["logs-path"]) vscode.logsPath = values["logs-path"];
 const dir = positionals[0];
 if (dir) vscode["disable-workspace-trust"] = true;
-const handle = await startCodeServer({
+let handle;
+let shuttingDown = false;
+const shutdown = () => {
+	if (shuttingDown) process.exit(0);
+	shuttingDown = true;
+	setTimeout(() => process.exit(0), 3e3).unref();
+	if (handle) handle.close().finally(() => process.exit(0));
+	else process.exit(0);
+};
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+handle = await startCodeServer({
 	port: values.port ? Number(values.port) : void 0,
 	host: values.host,
+	socketPath: values["socket-path"],
+	baseURL: values["base-url"] ?? values["server-base-path"],
 	defaultFolder: dir || values["default-folder"],
 	connectionToken: values["connection-token"] ?? values.token,
 	vscode
@@ -247,13 +260,4 @@ if (values.open) {
 	else if (platform === "win32") exec(`start chrome --app="${url}" || start msedge --app="${url}" || start "" "${url}"`);
 	else exec(`google-chrome-stable --app="${url}" 2>/dev/null || google-chrome --app="${url}" 2>/dev/null || chromium --app="${url}" 2>/dev/null || xdg-open "${url}"`);
 }
-let shuttingDown = false;
-const shutdown = () => {
-	if (shuttingDown) process.exit(0);
-	shuttingDown = true;
-	setTimeout(() => process.exit(0), 3e3).unref();
-	handle.close().finally(() => process.exit(0));
-};
-process.on("SIGINT", shutdown);
-process.on("SIGTERM", shutdown);
 export {};

package/dist/index.d.mts

@@ -85,24 +85,35 @@ interface CreateCodeServerOptions {
   connectionToken?: string;
   /** Host/interface to bind (used to infer local-only access for token default). */
   host?: string;
+  /**
+   * Base URL the server is mounted under (e.g. `/code`). Defaults to `/`.
+   * Forwarded to VS Code as `server-base-path` and honored by coderaft's own
+   * routes (`/healthz`, `/_static/*`, `/proxy/*`, `/login`, …).
+   */
+  baseURL?: string;
   /** Extra options forwarded to VS Code's `createServer()`. */
   vscode?: VSCodeServerOptions;
 }
 interface StartCodeServerOptions extends CreateCodeServerOptions {
-  /** TCP port to listen on. Defaults to `$PORT` or `6063`. */
+  /** TCP port to listen on. Defaults to `$PORT` or `6063`. Ignored when `socketPath` is set. */
   port?: number;
+  /** Unix socket path to listen on. When set, `port` and `host` are ignored. */
+  socketPath?: string;
 }
 interface CodeServerHandler {
   /** Node-style HTTP request handler (middleware). */
   handleRequest(req: IncomingMessage, res: ServerResponse): void;
   /** Handle WebSocket upgrade. */
-  handleUpgrade(req: IncomingMessage, socket: Duplex): void;
+  handleUpgrade(req: IncomingMessage, socket: Duplex, head: Buffer): void;
   connectionToken: string;
   dispose(): Promise<void>;
 }
 interface CodeServerHandle {
   server: Server;
-  port: number;
+  /** TCP port the server is bound to, or `undefined` when listening on a unix socket. */
+  port?: number;
+  /** Unix socket path the server is bound to, or `undefined` when listening on TCP. */
+  socketPath?: string;
   url: string;
   connectionToken: string;
   close(): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coderaft",
-  "version": "0.0.15",
+  "version": "0.0.18",
   "repository": "pithings/coderaft",
   "bin": {
     "coderaft": "./dist/cli.mjs"
@@ -11,11 +11,13 @@
     "ThirdPartyNotices.txt",
     "tar.mjs",
     "code.mjs",
+    "android-preload.cjs",
     "code.tar.zst"
   ],
   "type": "module",
   "imports": {
-    "#code": "./code.mjs"
+    "#code": "./code.mjs",
+    "#android-preload": "./android-preload.cjs"
   },
   "scripts": {
     "build": "obuild"
@@ -62,6 +64,7 @@
     "vscode-oniguruma": "1.7.0",
     "vscode-regexpp": "^3.1.0",
     "vscode-textmate": "^9.3.2",
+    "httpxy": "^0.5.0",
     "ws": "^8.19.0",
     "yauzl": "^3.0.0",
     "yazl": "^2.4.3"