@linxin666/dsh-remote-web-ui 0.1.12 → 0.1.14

package/lib/index.js

@@ -1,6 +1,6 @@
 import { createRequire } from "node:module";
 import { setInterval as setInterval$1 } from "node:timers";
-import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
+import { Service } from "@deepseek-ai/cordis";
 import z from "schemastery";
 import { randomBytes } from "node:crypto";
 import { readFile } from "node:fs/promises";
@@ -11,6 +11,203 @@ import { networkInterfaces } from "node:os";
 import { Tunnel, bin, install } from "cloudflared";
 import { dirname, join } from "node:path";
 import { spawn } from "node:child_process";
+//#region ../../node_modules/.pnpm/@deepseek-ai+dsh-settings@0.1.0-rc.6_@deepseek-ai+cordis@4.0.1_@deepseek-ai+dsh-brand@0_52495af71738a1095726249ceff4fd7b/node_modules/@deepseek-ai/dsh-settings/lib/index.js
+/**
+* Structural secret redaction for settings values. `role('secret')` fields are
+* removed from a value before it crosses a wire boundary; a sidecar records
+* each schema-declared secret position and whether it currently holds a value,
+* so a configuration surface can render a write-only input without ever
+* receiving the secret itself.
+* @module @deepseek-ai/dsh-settings/redact
+*/
+/** Whether a value is a plain data object the walker may recurse into. */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function walk(node, value, path, secrets) {
+	if (node === void 0) return value;
+	if (node.meta?.role === "secret") {
+		secrets.push({
+			path,
+			set: value !== void 0
+		});
+		return;
+	}
+	switch (node.type) {
+		case "object": {
+			const properties = node.dict ?? {};
+			const source = isRecord(value) ? value : void 0;
+			const rebuilt = {};
+			if (source !== void 0) for (const [key, entry] of Object.entries(source)) {
+				if (key in properties) continue;
+				rebuilt[key] = entry;
+			}
+			for (const [key, child] of Object.entries(properties)) {
+				const stripped = walk(child, source?.[key], [...path, key], secrets);
+				if (stripped !== void 0) rebuilt[key] = stripped;
+			}
+			return source === void 0 && Object.keys(rebuilt).length === 0 ? value : rebuilt;
+		}
+		case "dict": {
+			if (!isRecord(value)) return value;
+			const rebuilt = {};
+			for (const [key, entry] of Object.entries(value)) {
+				const stripped = walk(node.inner, entry, [...path, key], secrets);
+				if (stripped !== void 0) rebuilt[key] = stripped;
+			}
+			return rebuilt;
+		}
+		case "array":
+			if (!Array.isArray(value)) return value;
+			return value.map((entry, index) => walk(node.inner, entry, [...path, String(index)], secrets));
+		default: return value;
+	}
+}
+/**
+* Service Definition for the user-settings capability seam (`ctx.settings`). Providers store one raw document of
+* per-namespace sections; plugins register a namespace schema and read the
+* resolved value, which layers schema defaults, the registrant's composition
+* `base`, and the user document section, in that order.
+* @module @deepseek-ai/dsh-settings
+*/
+const NAMESPACE_PATTERN = /^[a-z][a-z0-9-]*$/;
+/**
+* Brand a raw string as a {@link SettingsNamespace}.
+* @param value - candidate namespace; lowercase kebab-case, as in plugin short names.
+* @returns the branded namespace.
+*/
+function settingsNamespace(value) {
+	if (!NAMESPACE_PATTERN.test(value)) throw new TypeError(`settings namespace "${value}" must match ${String(NAMESPACE_PATTERN)}`);
+	return value;
+}
+/**
+* Deep equality over JSON-compatible data (objects, arrays, primitives) — the
+* Service Definition's single change-detection predicate, exported so the invariant
+* companion checks exactly the implementation's relation.
+* @param a - one JSON-compatible value.
+* @param b - the other JSON-compatible value.
+* @returns whether the two values are structurally equal.
+*/
+function deepEqualJson(a, b) {
+	if (a === b) return true;
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	if (Array.isArray(a) || Array.isArray(b)) {
+		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+		return a.every((entry, index) => deepEqualJson(entry, b[index]));
+	}
+	const left = a;
+	const right = b;
+	const keys = Object.keys(left);
+	if (keys.length !== Object.keys(right).length) return false;
+	return keys.every((key) => key in right && deepEqualJson(left[key], right[key]));
+}
+/** Whether a value is a plain data object (not an array, null, or class instance). */
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+/** Apply one path op to a detached section, returning the next section. */
+function applyPathOp(section, op) {
+	const [head, ...rest] = op.path;
+	if (head === void 0) {
+		if (op.op === "unset") return {};
+		if (!isPlainObject(op.value)) throw new TypeError("settings mutate: setting the section root requires a plain object");
+		return { ...op.value };
+	}
+	if (rest.length === 0) {
+		if (op.op === "set") return {
+			...section,
+			[head]: op.value
+		};
+		const { [head]: _removed, ...kept } = section;
+		return kept;
+	}
+	const child = section[head];
+	if (!isPlainObject(child)) {
+		if (op.op === "unset") return section;
+		return {
+			...section,
+			[head]: applyPathOp({}, {
+				...op,
+				path: rest
+			})
+		};
+	}
+	return {
+		...section,
+		[head]: applyPathOp(child, {
+			...op,
+			path: rest
+		})
+	};
+}
+/**
+* Layer `over` onto `under`: plain objects merge recursively, every other
+* value (arrays included) replaces the lower layer wholesale. `over` never
+* carries `undefined` entries — sections come from parsed documents and write
+* snapshots pass {@link cloneJsonShaped}, which strips them so a sparse patch
+* cannot erase lower keys.
+*/
+function mergeLayers(under, over) {
+	if (over === void 0) return under;
+	if (!isPlainObject(under) || !isPlainObject(over)) return over;
+	const merged = { ...under };
+	for (const [key, value] of Object.entries(over)) merged[key] = key in merged ? mergeLayers(merged[key], value) : value;
+	return merged;
+}
+/** Recursively freeze one resolved value so handed-out snapshots stay immutable. */
+function deepFreeze(value) {
+	if (typeof value !== "object" || value === null || Object.isFrozen(value)) return value;
+	for (const entry of Object.values(value)) deepFreeze(entry);
+	return Object.freeze(value);
+}
+Service.init;
+/**
+* Value mirror of the `FiberState` members {@link isUnloading} compares
+* against: a const enum has no runtime object to import, and the value is
+* needed at runtime (same rationale as the CLI boot driver's mirror).
+*/
+const FIBER_DISPOSED = 4;
+const FIBER_UNLOADING = 5;
+/** Whether the consumer's own fiber is tearing down (not just losing the settings service). */
+function isUnloading(ctx) {
+	const state = ctx.fiber.state;
+	return state === FIBER_UNLOADING || state === FIBER_DISPOSED;
+}
+/**
+* Install the canonical optional-settings consumer wiring: while a settings
+* service exists, register `ns` with the consumer's composition entry as the
+* `base` layer and point the source thunk at the resolved scope; when the
+* service goes away (disposal, provider reload), fall back to the entry so
+* the consumer keeps working exactly as composed. The registration rides the
+* scoped fiber, so no settings service ever mounted means none of this runs.
+* @param ctx - consumer plugin context owning the wiring.
+* @param ns - the consumer-owned settings namespace.
+* @param schema - schema resolving the namespace (typically the plugin Config).
+* @param entry - the consumer's composition entry config, used as `base`.
+* @param hooks - source sink and change notification.
+*/
+function installSettingsSection(ctx, ns, schema, entry, hooks) {
+	ctx.inject(["settings"], (sctx) => {
+		const scope = sctx.settings.register(ns, schema, {
+			base: entry,
+			...hooks.validate === void 0 ? {} : { validate: hooks.validate }
+		});
+		hooks.setSource(() => scope.get());
+		sctx.effect(() => () => {
+			if (isUnloading(ctx)) return;
+			hooks.setSource(() => entry);
+			hooks.onChange();
+		});
+		hooks.onChange();
+		scope.watch(() => {
+			if (isUnloading(ctx)) return;
+			hooks.onChange();
+		});
+	});
+}
+//#endregion
 //#region src/pairing.ts
 /**
 * Pairing state machine: one active one-time token, a device-session table,
@@ -803,6 +1000,12 @@ const MOBILE_ALLOWLIST = /* @__PURE__ */ new Set([
 	"session.selectModel",
 	"session.rename"
 ]);
+/**
+* Locally answered display-preference method (the phone's read-only
+* surface preferences; never proxied to the host ApiProxy and never a
+* settings-domain write).
+*/
+const MOBILE_PREFERENCES_METHOD = "mobile.preferences";
 /** One session.list page (thin phones load incrementally). */
 const SESSION_PAGE_SIZE = 20;
 /** Encode one list position as an opaque continuation cursor. */
@@ -836,7 +1039,7 @@ const MOBILE_API_METHOD_PREFIX = `${MOBILE_API_PREFIX}/`;
 * @returns the routes to register on webServer.
 */
 function makeMobileApiRoutes(deps) {
-	const { service, apiProxy } = deps;
+	const { service, apiProxy, mobileEnterToSend } = deps;
 	/** The phone gate: a live paired-device cookie, or nothing else proceeds. */
 	const gateOk = (req) => {
 		const deviceId = readCookie(req.headers.cookie, service.config.cookieName);
@@ -874,7 +1077,8 @@ function makeMobileApiRoutes(deps) {
 			return;
 		}
 		const method = pathname.slice(MOBILE_API_METHOD_PREFIX.length);
-		if (!MOBILE_ALLOWLIST.has(method)) {
+		const local = method === MOBILE_PREFERENCES_METHOD;
+		if (!MOBILE_ALLOWLIST.has(method) && !local) {
 			writeJson(res, 403, {
 				ok: false,
 				error: {
@@ -909,6 +1113,17 @@ function makeMobileApiRoutes(deps) {
 			});
 			return;
 		}
+		if (local) {
+			writeJson(res, 200, {
+				type: "server-response",
+				rpcId,
+				result: {
+					ok: true,
+					value: { mobileEnterToSend: mobileEnterToSend() }
+				}
+			});
+			return;
+		}
 		try {
 			const response = await dispatch(apiProxy, method, parsed?.payload, rpcId);
 			writeJson(res, 200, response);
@@ -1500,30 +1715,85 @@ async function checkUpdates(deps) {
 /** Cap on captured pnpm output (keeps error payloads bounded). */
 const OUTPUT_CAP = 16 * 1024;
 /**
-* Run the update: `pnpm update <packages>` inside the profile directory.
+* Windows cmd command-not-found stderr. With shell:true a missing shim
+* exits with code 1 (cmd cannot report ENOENT), so the fallback chain
+* detects this message instead of the spawn error event.
+*/
+const WIN_CMD_MISSING_RE = /not recognized as an internal or external command/i;
+/**
+* Run the update inside the profile directory. Tries pnpm first, falls back
+* to corepack and then npx when the previous command is missing (ENOENT);
+* all candidates share one hard timeout and keep accumulating output.
 * @param deps - profile dir, package list, and spawn/timeout seams.
 * @returns the outcome with captured output.
 */
 function runUpdate(deps) {
 	return new Promise((resolve) => {
-		const child = (deps.spawnImpl ?? spawn)("pnpm", ["update", ...deps.packages], {
+		const spawnImpl = deps.spawnImpl ?? spawn;
+		const packages = deps.packages;
+		const platform = deps.platform ?? process.platform;
+		const spawnOptions = {
 			cwd: deps.profileDir,
 			stdio: [
 				"ignore",
 				"pipe",
 				"pipe"
-			]
-		});
+			],
+			...platform === "win32" ? { shell: true } : {}
+		};
+		const candidates = [
+			{
+				command: "pnpm",
+				args: ["update", ...packages]
+			},
+			{
+				command: "corepack",
+				args: [
+					"pnpm",
+					"update",
+					...packages
+				]
+			},
+			{
+				command: "npx",
+				args: [
+					"--yes",
+					"pnpm",
+					"update",
+					...packages
+				]
+			}
+		];
 		let output = "";
+		let currentOutput = "";
 		const append = (chunk) => {
 			output += chunk.toString("utf8");
 			if (output.length > OUTPUT_CAP) output = output.slice(output.length - OUTPUT_CAP);
+			currentOutput += chunk.toString("utf8");
+			if (currentOutput.length > OUTPUT_CAP) currentOutput = currentOutput.slice(currentOutput.length - OUTPUT_CAP);
+		};
+		let currentChild;
+		let finished = false;
+		const finish = (result) => {
+			if (finished) return;
+			finished = true;
+			clearTimeout(timer);
+			resolve(result);
 		};
-		child.stdout?.on("data", append);
-		child.stderr?.on("data", append);
 		const timer = setTimeout(() => {
-			child.kill("SIGTERM");
-			resolve({
+			if (finished) return;
+			if (platform === "win32") {
+				const pid = currentChild?.pid;
+				if (pid !== void 0 && pid > 0) try {
+					spawnImpl("taskkill", [
+						"/pid",
+						String(pid),
+						"/t",
+						"/f"
+					], { stdio: "ignore" });
+				} catch {}
+			} else currentChild?.kill("SIGTERM");
+			finish({
 				ok: false,
 				exitCode: null,
 				output,
@@ -1531,27 +1801,59 @@ function runUpdate(deps) {
 				errorCode: "timeout"
 			});
 		}, deps.timeoutMs ?? 10 * 6e4);
-		child.on("error", (error) => {
-			clearTimeout(timer);
-			const missing = error.code === "ENOENT";
-			resolve({
-				ok: false,
-				exitCode: null,
-				output,
-				error: missing ? "pnpm not found on PATH" : error.message,
-				errorCode: missing ? "pnpm-missing" : void 0
+		const runCandidate = (index) => {
+			if (finished) return;
+			if (index >= candidates.length) {
+				finish({
+					ok: false,
+					exitCode: null,
+					output,
+					error: "pnpm not found on PATH (tried pnpm, corepack, npx); install pnpm and restart the app",
+					errorCode: "pnpm-missing"
+				});
+				return;
+			}
+			const candidate = candidates[index];
+			currentOutput = "";
+			const child = spawnImpl(candidate.command, candidate.args, spawnOptions);
+			currentChild = child;
+			let settled = false;
+			const once = (fn) => {
+				if (settled) return;
+				settled = true;
+				fn();
+			};
+			child.stdout?.on("data", append);
+			child.stderr?.on("data", append);
+			child.on("error", (error) => {
+				once(() => {
+					if (error.code === "ENOENT") runCandidate(index + 1);
+					else finish({
+						ok: false,
+						exitCode: null,
+						output,
+						error: error.message,
+						errorCode: void 0
+					});
+				});
 			});
-		});
-		child.on("close", (code) => {
-			clearTimeout(timer);
-			resolve({
-				ok: code === 0,
-				exitCode: code,
-				output,
-				error: code === 0 ? void 0 : "pnpm exited with code " + String(code),
-				...code === 0 ? {} : { errorCode: "pnpm-failed" }
+			child.on("close", (code) => {
+				if (settled || finished) return;
+				if (platform === "win32" && code !== 0 && WIN_CMD_MISSING_RE.test(currentOutput)) {
+					runCandidate(index + 1);
+					return;
+				}
+				settled = true;
+				finish({
+					ok: code === 0,
+					exitCode: code,
+					output,
+					error: code === 0 ? void 0 : "pnpm exited with code " + String(code),
+					...code === 0 ? {} : { errorCode: "pnpm-failed" }
+				});
 			});
-		});
+		};
+		runCandidate(0);
 	});
 }
 //#endregion
@@ -1645,6 +1947,7 @@ const Config = z.object({
 	requirePairingForLan: z.boolean().default(true),
 	publicBaseUrl: z.string(),
 	autoTunnel: z.boolean().default(false),
+	mobileEnterToSend: z.boolean().default(true),
 	enabled: z.boolean().default(true)
 });
 /** Presence sweep cadence (a stale device flips to disconnected within two sweeps). */
@@ -1658,6 +1961,7 @@ const DEFAULTS = {
 	requirePairingForLan: true,
 	publicBaseUrl: void 0,
 	autoTunnel: false,
+	mobileEnterToSend: true,
 	enabled: true
 };
 /**
@@ -1674,6 +1978,7 @@ function apply(ctx, config) {
 		requirePairingForLan: config?.requirePairingForLan ?? DEFAULTS.requirePairingForLan,
 		publicBaseUrl: config?.publicBaseUrl,
 		autoTunnel: config?.autoTunnel ?? DEFAULTS.autoTunnel,
+		mobileEnterToSend: config?.mobileEnterToSend ?? DEFAULTS.mobileEnterToSend,
 		enabled: config?.enabled ?? DEFAULTS.enabled
 	};
 	let current = () => config ?? {};
@@ -1687,6 +1992,7 @@ function apply(ctx, config) {
 			requirePairingForLan: value.requirePairingForLan ?? DEFAULTS.requirePairingForLan,
 			publicBaseUrl: value.publicBaseUrl,
 			autoTunnel: value.autoTunnel ?? DEFAULTS.autoTunnel,
+			mobileEnterToSend: value.mobileEnterToSend ?? DEFAULTS.mobileEnterToSend,
 			enabled: value.enabled ?? DEFAULTS.enabled
 		};
 	};
@@ -1771,7 +2077,8 @@ function apply(ctx, config) {
 		...makeMobileRoutes(),
 		...apiProxy !== void 0 ? makeMobileApiRoutes({
 			service,
-			apiProxy
+			apiProxy,
+			mobileEnterToSend: () => resolve().mobileEnterToSend
 		}) : [],
 		...updateRoutes
 	];