dsh-mobile 0.3.14 → 0.3.15

package/lib/index.d.mts

@@ -645,7 +645,20 @@ declare class MobileAccessGateway {
   private proxyMobileIndex;
   private rememberMobileBootBatch;
   private serveMobileBootBatch;
+  private startMobileBootBatchAssembly;
   private assembleMobileBootBatch;
+  /**
+   * Read one upstream bundle, retrying transient connection failures.
+   *
+   * Assembling a batch fans out over every client entry, and the upstream
+   * resets a fraction of those connections before sending a byte
+   * (`read ECONNRESET`, recv=0) — randomly, on any entry, at any concurrency.
+   * A single such reset used to fail the whole batch with 502
+   * `upstream_unavailable`, surfacing in the browser as "bundle script
+   * /mobile-access/mobile-boot/<hash>.js failed to load". Retrying recovers
+   * every observed reset; a genuine upstream error still fails.
+   */
+  private readUpstreamClientBundleWithRetry;
   private readUpstreamClientBundle;
   private allocateRequest;
   private proxyHttp;

package/lib/index.mjs

@@ -1061,7 +1061,8 @@ const AUTH_PREFIX = "/mobile-access";
 const WS_PATHS = /* @__PURE__ */ new Set([
 	"/api/events.mux",
 	"/api/events.host",
-	"/api/remote.mux"
+	"/api/remote.mux",
+	"/sidebar/ws/terminal"
 ]);
 /** Terse request failure safe to expose without internal diagnostics. */
 var HttpError = class extends Error {
@@ -2108,6 +2109,21 @@ const MOBILE_BOOT_BATCH_PREFIX = `${AUTH_PREFIX}/mobile-boot/`;
 const MAX_MOBILE_BOOT_BATCH_BYTES = 33554432;
 const MAX_MOBILE_BOOT_ENTRY_BYTES = 8388608;
 const MAX_MOBILE_BOOT_BATCHES = 8;
+const MOBILE_BOOT_UPSTREAM_ATTEMPTS = 4;
+const MOBILE_BOOT_RETRY_DELAY_MS = 150;
+const TRANSIENT_UPSTREAM_ERROR_CODES = /* @__PURE__ */ new Set([
+	"EAI_AGAIN",
+	"ECONNABORTED",
+	"ECONNREFUSED",
+	"ECONNRESET",
+	"EPIPE",
+	"EHOSTUNREACH",
+	"ENETDOWN",
+	"ENETRESET",
+	"ENETUNREACH",
+	"ETIMEDOUT",
+	"ERR_STREAM_PREMATURE_CLOSE"
+]);
 const UPSTREAM_AUTH_REFRESH_MARGIN_MS = 6e4;
 const UPSTREAM_COOKIE_PAIR = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+=[\x21-\x3A\x3C-\x7E]*$/u;
 const CUSTOM_STYLE_FALLBACK = "/* Add mobile overrides in the DSH home mobile-access/mobile.css file. */\n";
@@ -2575,6 +2591,51 @@ function mapError(error) {
 	if (error instanceof MobileExtensionError) return new HttpError(error.status, error.code);
 	return new HttpError(500, "internal_error");
 }
+function requestAbortedError() {
+	const error = /* @__PURE__ */ new Error("request aborted");
+	error.name = "AbortError";
+	return error;
+}
+function isTransientUpstreamError(error) {
+	if (!(error instanceof Error)) return false;
+	const code = error.code;
+	return typeof code === "string" && TRANSIENT_UPSTREAM_ERROR_CODES.has(code);
+}
+function upstreamTimeoutError() {
+	const error = /* @__PURE__ */ new Error("upstream timeout");
+	error.code = "ETIMEDOUT";
+	return error;
+}
+function waitForAbortableDelay(delayMs, signal) {
+	if (signal.aborted) return Promise.reject(requestAbortedError());
+	return new Promise((resolve, reject) => {
+		const aborted = () => {
+			clearTimeout(timer);
+			reject(requestAbortedError());
+		};
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", aborted);
+			resolve();
+		}, delayMs);
+		signal.addEventListener("abort", aborted, { once: true });
+	});
+}
+function waitForRequestTask(task, signal) {
+	if (signal.aborted) return Promise.reject(requestAbortedError());
+	return new Promise((resolve, reject) => {
+		const aborted = () => {
+			reject(requestAbortedError());
+		};
+		signal.addEventListener("abort", aborted, { once: true });
+		task.then((value) => {
+			signal.removeEventListener("abort", aborted);
+			resolve(value);
+		}, (error) => {
+			signal.removeEventListener("abort", aborted);
+			reject(error);
+		});
+	});
+}
 function discoveryDeviceName() {
 	const value = hostname().trim().replaceAll(/[\u0000-\u001f\u007f]/gu, "");
 	return (value === "" ? "DeepSeek Harness" : value).slice(0, 63);
@@ -3574,6 +3635,7 @@ var MobileAccessGateway = class {
 		while (this.mobileBootBatches.size > MAX_MOBILE_BOOT_BATCHES) {
 			const oldest = this.mobileBootBatches.keys().next().value;
 			if (oldest === void 0) break;
+			this.mobileBootBatches.get(oldest)?.assembly?.controller.abort();
 			this.mobileBootBatches.delete(oldest);
 		}
 	}
@@ -3582,17 +3644,17 @@ var MobileAccessGateway = class {
 		const stored = this.mobileBootBatches.get(key);
 		if (stored === void 0) throw new HttpError(404, "not_found");
 		const operation = this.allocateRequest(authorization, response, {});
+		response.once("close", operation.abort);
 		try {
 			const layoutStat = await stat(this.config.mobileLayoutFile);
 			if (stored.body === void 0 || stored.etag === void 0 || stored.layoutMtimeMs !== layoutStat.mtimeMs) {
-				const body = await this.assembleMobileBootBatch(stored.plan, operation.signal);
-				stored.body = body;
-				delete stored.gzipBody;
-				stored.etag = createHash("sha256").update(body).digest("hex");
-				stored.layoutMtimeMs = layoutStat.mtimeMs;
+				operation.signal.throwIfAborted();
+				await waitForRequestTask((stored.assembly ?? this.startMobileBootBatchAssembly(stored, layoutStat.mtimeMs)).task, operation.signal);
 			}
 			const compressed = acceptsGzip(request.headers["accept-encoding"]);
-			const body = compressed ? stored.gzipBody ??= await gzipBuffer(stored.body) : stored.body;
+			const assembled = stored.body;
+			if (assembled === void 0) throw new HttpError(502, "upstream_unavailable");
+			const body = compressed ? stored.gzipBody ??= await gzipBuffer(assembled) : assembled;
 			const etag = compressed ? `${stored.etag}-gzip` : stored.etag;
 			const headers = {
 				"Content-Type": "text/javascript; charset=utf-8",
@@ -3620,9 +3682,32 @@ var MobileAccessGateway = class {
 			if (error.code === "ENOENT") throw new HttpError(503, "mobile_frontend_unavailable");
 			throw error;
 		} finally {
+			response.removeListener("close", operation.abort);
 			operation.release();
 		}
 	}
+	startMobileBootBatchAssembly(stored, layoutMtimeMs) {
+		const controller = new AbortController();
+		const task = (async () => {
+			const body = await this.assembleMobileBootBatch(stored.plan, controller.signal);
+			stored.body = body;
+			delete stored.gzipBody;
+			stored.etag = createHash("sha256").update(body).digest("hex");
+			stored.layoutMtimeMs = layoutMtimeMs;
+			return body;
+		})();
+		const assembly = Object.freeze({
+			controller,
+			task
+		});
+		stored.assembly = assembly;
+		task.then(() => {
+			if (stored.assembly === assembly) delete stored.assembly;
+		}, () => {
+			if (stored.assembly === assembly) delete stored.assembly;
+		});
+		return assembly;
+	}
 	async assembleMobileBootBatch(plan, signal) {
 		const bodies = new Array(plan.entries.length);
 		let cursor = 0;
@@ -3630,15 +3715,41 @@ var MobileAccessGateway = class {
 			while (cursor < plan.entries.length) {
 				const index = cursor++;
 				const entry = plan.entries[index];
-				bodies[index] = entry.id === MOBILE_LAYOUT_MODULE ? await readFile(this.config.mobileLayoutFile, { signal }) : await this.readUpstreamClientBundle(entry.url, signal);
+				bodies[index] = entry.id === MOBILE_LAYOUT_MODULE ? await readFile(this.config.mobileLayoutFile, { signal }) : await this.readUpstreamClientBundleWithRetry(entry.url, signal);
 				if (bodies[index].byteLength > MAX_MOBILE_BOOT_ENTRY_BYTES) throw new HttpError(502, "upstream_unavailable");
 			}
 		};
-		await Promise.all(Array.from({ length: Math.min(8, plan.entries.length) }, worker));
+		await Promise.all(Array.from({ length: Math.min(3, plan.entries.length) }, worker));
 		if (bodies.reduce((bytes, body) => bytes + body.byteLength + 2, 0) > MAX_MOBILE_BOOT_BATCH_BYTES) throw new HttpError(502, "upstream_unavailable");
 		return Buffer.concat(bodies.flatMap((body) => [body, Buffer.from("\n;\n")]));
 	}
+	/**
+	* Read one upstream bundle, retrying transient connection failures.
+	*
+	* Assembling a batch fans out over every client entry, and the upstream
+	* resets a fraction of those connections before sending a byte
+	* (`read ECONNRESET`, recv=0) — randomly, on any entry, at any concurrency.
+	* A single such reset used to fail the whole batch with 502
+	* `upstream_unavailable`, surfacing in the browser as "bundle script
+	* /mobile-access/mobile-boot/<hash>.js failed to load". Retrying recovers
+	* every observed reset; a genuine upstream error still fails.
+	*/
+	async readUpstreamClientBundleWithRetry(source, signal) {
+		for (let attempt = 1; attempt <= MOBILE_BOOT_UPSTREAM_ATTEMPTS; attempt++) {
+			signal.throwIfAborted();
+			try {
+				return await this.readUpstreamClientBundle(source, signal);
+			} catch (error) {
+				if (signal.aborted) throw error;
+				if (!isTransientUpstreamError(error)) throw error;
+				if (attempt === MOBILE_BOOT_UPSTREAM_ATTEMPTS) throw new HttpError(502, "upstream_unavailable");
+				await waitForAbortableDelay(MOBILE_BOOT_RETRY_DELAY_MS * attempt, signal);
+			}
+		}
+		throw new HttpError(502, "upstream_unavailable");
+	}
 	async readUpstreamClientBundle(source, signal) {
+		signal.throwIfAborted();
 		if (!source.startsWith("/plugins/") || source.includes("#")) throw new HttpError(502, "upstream_unavailable");
 		const target = new URL(source, this.config.upstreamOrigin);
 		if (target.origin !== this.config.upstreamOrigin.origin) throw new HttpError(502, "upstream_unavailable");
@@ -3649,6 +3760,7 @@ var MobileAccessGateway = class {
 		signal.addEventListener("abort", aborted, { once: true });
 		try {
 			const upstreamCookie = await this.upstreamCookieHeader();
+			signal.throwIfAborted();
 			const proxied = await new Promise((resolve, reject) => {
 				upstreamRequest = request({
 					protocol: "http:",
@@ -3665,7 +3777,7 @@ var MobileAccessGateway = class {
 					agent: false
 				});
 				upstreamRequest.setTimeout(this.config.upstreamTimeoutMs, () => {
-					upstreamRequest?.destroy(/* @__PURE__ */ new Error("upstream timeout"));
+					upstreamRequest?.destroy(upstreamTimeoutError());
 				});
 				upstreamRequest.once("response", resolve);
 				upstreamRequest.once("error", reject);
@@ -3683,6 +3795,7 @@ var MobileAccessGateway = class {
 			return Buffer.concat(chunks);
 		} catch (error) {
 			if (error instanceof HttpError) throw error;
+			if (signal.aborted || isTransientUpstreamError(error)) throw error;
 			throw new HttpError(502, "upstream_unavailable");
 		} finally {
 			signal.removeEventListener("abort", aborted);
@@ -3708,6 +3821,7 @@ var MobileAccessGateway = class {
 		return {
 			id,
 			signal: controller.signal,
+			abort,
 			release: () => {
 				const entry = this.activeRequests.get(id);
 				if (entry !== void 0) clearTimeout(entry.timer);
@@ -4105,6 +4219,7 @@ var MobileAccessGateway = class {
 		this.upstreamAuthRequest = void 0;
 		this.removeSessionListener();
 		const accessClose = this.access.close();
+		for (const stored of this.mobileBootBatches.values()) stored.assembly?.controller.abort();
 		for (const request of this.activeRequests.values()) request.abort();
 		for (const websocket of this.activeWebSockets.values()) {
 			websocket.client.destroy();
@@ -7340,6 +7455,18 @@ async function reserveLoopbackPort() {
 		}
 	};
 }
+function spawnCpolarProcess(executable, args, environment) {
+	return spawn(executable, [...args], {
+		env: environment,
+		shell: false,
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		],
+		windowsHide: true
+	});
+}
 function withoutProxyEnvironment(environment) {
 	const blocked = /* @__PURE__ */ new Set([
 		"HTTP_PROXY",
@@ -7526,16 +7653,7 @@ var CpolarController = class {
 			"-log-level=INFO",
 			String(reservation.port)
 		];
-		const child = spawn(this.options.executable, args, {
-			env: withoutProxyEnvironment(process.env),
-			shell: false,
-			stdio: [
-				"pipe",
-				"pipe",
-				"pipe"
-			],
-			windowsHide: true
-		});
+		const child = (this.options.spawnProcess ?? spawnCpolarProcess)(this.options.executable, args, withoutProxyEnvironment(process.env));
 		this.child = child;
 		child.stdout.setEncoding("utf8");
 		child.stderr.setEncoding("utf8");
@@ -7581,7 +7699,13 @@ var CpolarController = class {
 		}
 	}
 	async attachGateway(generation, origin) {
-		if (generation !== this.generation || !this.enabled || this.gatewayValue !== void 0) return;
+		if (generation !== this.generation || !this.enabled || this.disposed) return;
+		const current = this.gatewayValue;
+		if (current !== void 0) {
+			if (current.address().origin === origin) return;
+			await this.rotateGateway(generation, origin, current);
+			return;
+		}
 		const reservation = this.reservation;
 		if (reservation === void 0) return;
 		this.publish({
@@ -7598,7 +7722,7 @@ var CpolarController = class {
 			await this.failGeneration(generation, "gateway_start_failed");
 			return;
 		}
-		if (generation !== this.generation || !this.enabled) {
+		if (generation !== this.generation || !this.enabled || this.disposed || this.child === void 0) {
 			await gateway.close();
 			return;
 		}
@@ -7611,6 +7735,40 @@ var CpolarController = class {
 			origin
 		});
 	}
+	/** Replace the gateway authority when cpolar rotates a temporary public origin. */
+	async rotateGateway(generation, origin, current) {
+		const listenPort = current.address().port;
+		if (this.gatewayValue === current) this.gatewayValue = void 0;
+		this.publish({
+			enabled: true,
+			state: "connecting",
+			origin
+		});
+		try {
+			await current.close();
+		} catch {
+			await this.failGeneration(generation, "gateway_start_failed");
+			return;
+		}
+		if (generation !== this.generation || !this.enabled || this.disposed || this.child === void 0) return;
+		let replacement;
+		try {
+			replacement = await this.options.createGateway(origin, listenPort);
+		} catch {
+			await this.failGeneration(generation, "gateway_start_failed");
+			return;
+		}
+		if (generation !== this.generation || !this.enabled || this.disposed || this.child === void 0) {
+			await replacement.close();
+			return;
+		}
+		this.gatewayValue = replacement;
+		this.publish({
+			enabled: true,
+			state: "ready",
+			origin
+		});
+	}
 	async failGeneration(generation, code) {
 		if (generation !== this.generation) return;
 		await this.stopProcessAndGateway();
@@ -8582,9 +8740,28 @@ async function settleCleanupSteps(steps) {
 	if (errors.length === 1 && errors[0] instanceof Error) throw errors[0];
 	if (errors.length > 0) throw new AggregateError(errors, "DSH Mobile cleanup failed");
 }
+/**
+* Resolve the DSH launch-token URL the gateway exchanges for its upstream cookie.
+*
+* A layer that disables DSH browser authentication — dsh-lan-access with
+* `noAuth: true` replaces `authenticatedUrl` with one returning the bare origin
+* — produces a URL with no query string, so it cannot carry a launch token. That
+* is a legitimate "this upstream needs no browser auth" signal: report no URL and
+* the gateway proxies without a cookie instead of failing every route with
+* `upstream_unavailable`. A token-bearing URL keeps the existing exchange, and a
+* connection service that is absent or returns a malformed URL keeps failing
+* closed. Only parsing is guarded: a connection service that throws still fails
+* plugin activation loudly rather than silently proxying without authentication.
+*/
 function upstreamAuthenticatedUrl(ctx, upstreamOrigin) {
 	const connection = ctx.connection;
-	return typeof connection?.authenticatedUrl === "function" ? connection.authenticatedUrl(upstreamOrigin.origin) : void 0;
+	if (typeof connection?.authenticatedUrl !== "function") return void 0;
+	const authenticatedUrl = connection.authenticatedUrl(upstreamOrigin.origin);
+	try {
+		return new URL(authenticatedUrl).search === "" ? void 0 : authenticatedUrl;
+	} catch {
+		return;
+	}
 }
 function installedDshVersion() {
 	try {