dsh-multi-chat 1.0.2 → 1.0.4

package/lib/index.js

@@ -1,6 +1,6 @@
 import { execFile, spawn } from "node:child_process";
 import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, readlinkSync } from "node:fs";
 import { networkInterfaces } from "node:os";
 import z from "@deepseek-ai/schemastery";
 import { connect, createServer } from "node:net";
@@ -542,10 +542,15 @@ function json(res, value, status = 200) {
 	res.end(JSON.stringify(value));
 }
 /**
+
 * Run a command and resolve its stdout text. Rejects on non-zero exit.
+
 * @param file - the executable path.
+
 * @param args - CLI arguments.
+
 * @returns the trimmed stdout.
+
 */
 function execStdout(file, args) {
 	return new Promise((resolve, reject) => {
@@ -559,36 +564,145 @@ function execStdout(file, args) {
 	});
 }
 /**
+
+* Whether an exec failure means the binary itself is absent (ENOENT) rather
+
+* than the command running and reporting a non-zero exit.
+
+* @param error - the rejection from {@link execStdout}.
+
+* @returns true when the executable could not be spawned at all.
+
+*/
+function isMissingBinary(error) {
+	return error?.code === "ENOENT";
+}
+/**
+
+* Read the local TCP sockets in LISTEN state from the kernel's `/proc` tables.
+
+* This is the Linux fallback for hosts without `lsof`, which is most
+
+* container images — including the ones `dsh web` is commonly run in. Only
+
+* this network namespace's sockets are visible, which is exactly the view the
+
+* serving instance and the instances it spawns live in.
+
+* @param port - restrict the scan to one port when given.
+
+* @returns listening port -> owning socket inode ('' when the row has none).
+
+*/
+function procListenSockets(port) {
+	const found = new Map();
+	for (const file of ["/proc/net/tcp", "/proc/net/tcp6"]) {
+		let text;
+		try {
+			text = readFileSync(file, "utf8");
+		} catch {
+			continue;
+		}
+		for (const line of text.split("\n").slice(1)) {
+			const f = line.trim().split(/\s+/);
+			if (f.length < 10 || f[3] !== "0A") continue;
+			const local = f[1] ?? "";
+			const listening = Number.parseInt(local.slice(local.indexOf(":") + 1), 16);
+			if (!Number.isInteger(listening) || listening <= 0) continue;
+			if (port !== void 0 && listening !== port) continue;
+			found.set(listening, f[9] ?? "");
+		}
+	}
+	return found;
+}
+/**
+
+* Resolve which PIDs own the given socket inodes by scanning `/proc/<pid>/fd`
+
+* links. Only processes this user is allowed to inspect are visible — the
+
+* same permission bound `lsof` has.
+
+* @param inodes - the socket inodes to look for.
+
+* @returns the owning PIDs (possibly empty).
+
+*/
+function pidsForInodes(inodes) {
+	const wanted = new Set([...inodes].filter((inode) => inode !== "").map((inode) => `socket:[${inode}]`));
+	if (wanted.size === 0) return [];
+	let entries;
+	try {
+		entries = readdirSync("/proc");
+	} catch {
+		return [];
+	}
+	const pids = new Set();
+	for (const entry of entries) {
+		const pid = Number(entry);
+		if (!Number.isInteger(pid) || pid <= 0) continue;
+		let fds;
+		try {
+			fds = readdirSync(`/proc/${entry}/fd`);
+		} catch {
+			continue;
+		}
+		for (const fd of fds) try {
+			if (wanted.has(readlinkSync(`/proc/${entry}/fd/${fd}`))) {
+				pids.add(pid);
+				break;
+			}
+		} catch {}
+	}
+	return [...pids];
+}
+/**
+
 * Resolve the PIDs listening on a local TCP port. Windows uses `netstat`;
-* POSIX uses `lsof` (present on macOS and most Linux installs).
+
+* POSIX prefers `lsof` and falls back to the kernel's `/proc` tables on Linux
+
+* hosts that do not ship it.
+
 * @param port - the listening port.
+
 * @returns the listener PIDs (possibly empty).
+
 */
 async function listeningPids(port) {
 	if (process.platform === "win32") {
-		const stdout$1 = await execStdout("netstat", [
+		const stdout = await execStdout("netstat", [
 			"-ano",
 			"-p",
 			"tcp"
 		]);
 		const pids = new Set();
-		for (const line of stdout$1.split(/\r?\n/)) {
+		for (const line of stdout.split(/\r?\n/)) {
 			const m = /^\s*TCP\s+([0-9.]+|\*|\[::\]):(\d+)\s+\S+\s+LISTENING\s+(\d+)\s*$/.exec(line);
 			if (m !== null && Number(m[2]) === port) pids.add(Number(m[3]));
 		}
 		return [...pids];
 	}
-	const stdout = await execStdout("lsof", [
-		"-ti",
-		`tcp:${port}`,
-		"-sTCP:LISTEN"
-	]);
-	return stdout.split(/\s+/).map(Number).filter((pid) => Number.isInteger(pid) && pid > 0);
+	try {
+		const stdout = await execStdout("lsof", [
+			"-ti",
+			`tcp:${port}`,
+			"-sTCP:LISTEN"
+		]);
+		return stdout.split(/\s+/).map(Number).filter((pid) => Number.isInteger(pid) && pid > 0);
+	} catch (error) {
+		if (process.platform !== "linux" || !isMissingBinary(error)) throw error;
+		return pidsForInodes(procListenSockets(port).values());
+	}
 }
 /**
+
 * Terminate one PID. Windows uses `taskkill /F` (force); POSIX sends SIGTERM
+
 * then SIGKILL after a grace period.
+
 * @param pid - the process id to terminate.
+
 */
 async function killPid(pid) {
 	if (process.platform === "win32") {
@@ -609,13 +723,21 @@ async function killPid(pid) {
 	} catch {}
 }
 /**
+
 * Terminate the DSH instance listening on one local port. The port serving
+
 * this wall may also be terminated (the user may want to stop the instance
+
 * they are viewing): the kill is deferred a beat so the HTTP response is
+
 * written before the process dies, then the listener's PIDs are force-killed.
+
 * @param port - the target port.
+
 * @param selfPort - this instance's own listening port.
+
 * @returns the stop result.
+
 */
 async function stopPort(port, selfPort) {
 	try {
@@ -649,12 +771,19 @@ async function stopPort(port, selfPort) {
 	}
 }
 /**
+
 * Resolve how to launch a new DSH instance. Primary path: the current
+
 * process's own entry (`node <bin> web` under `process.argv[1]`), so the new
+
 * instance inherits the exact CLI/profile already running. Fallback: the
+
 * `dsh` command from PATH when the entry cannot be derived (unusual host
+
 * launcher, missing file).
+
 * @returns the launcher description.
+
 */
 function resolveLauncher() {
 	const first = process.argv[1];
@@ -674,45 +803,66 @@ function resolveLauncher() {
 	};
 }
 /**
+
 * Collect every distinct local TCP port that is listening, in ONE command
+
 * (not one `netstat`/`lsof` per candidate, which the old free-port scan ran
+
 * sequentially and could take many seconds on slow Windows boxes). Windows
-* parses `netstat`; POSIX parses `lsof` `(LISTEN)` lines.
+
+* parses `netstat`; POSIX parses `lsof` `(LISTEN)` lines, falling back to
+
+* `/proc/net/tcp*` on Linux hosts without `lsof`.
+
 * @returns the set of busy ports.
+
 */
 async function listeningPorts() {
 	const set = new Set();
 	if (process.platform === "win32") {
-		const stdout$1 = await execStdout("netstat", [
+		const stdout = await execStdout("netstat", [
 			"-ano",
 			"-p",
 			"tcp"
 		]);
-		for (const line of stdout$1.split(/\r?\n/)) {
+		for (const line of stdout.split(/\r?\n/)) {
 			const m = /^\s*TCP\s+([0-9.]+|\*|\[::\]):(\d+)\s+\S+\s+LISTENING\s+(\d+)\s*$/.exec(line);
 			if (m !== null) set.add(Number(m[2]));
 		}
 		return set;
 	}
-	const stdout = await execStdout("lsof", [
-		"-nP",
-		"-iTCP",
-		"-sTCP:LISTEN"
-	]);
-	for (const line of stdout.split(/\r?\n/)) {
-		const m = /:(\d+)\s+\(LISTEN\)\s*$/.exec(line.trim());
-		if (m !== null) set.add(Number(m[1]));
+	try {
+		const stdout = await execStdout("lsof", [
+			"-nP",
+			"-iTCP",
+			"-sTCP:LISTEN"
+		]);
+		for (const line of stdout.split(/\r?\n/)) {
+			const m = /:(\d+)\s+\(LISTEN\)\s*$/.exec(line.trim());
+			if (m !== null) set.add(Number(m[1]));
+		}
+		return set;
+	} catch (error) {
+		if (process.platform !== "linux" || !isMissingBinary(error)) throw error;
+		return new Set(procListenSockets().keys());
 	}
-	return set;
 }
 /**
+
 * Pick the first free port in [lo, hi] that is neither the serving port nor
+
 * already listening. The busy set is resolved once (a single command), then
+
 * scanned in memory.
+
 * @param lo - first port of the range.
+
 * @param hi - last port of the range.
+
 * @param selfPort - the port serving this wall (never chosen).
+
 * @returns a free port, or undefined when the range is exhausted.
+
 */
 async function pickFreePort(lo, hi, selfPort) {
 	const busy = await listeningPorts();
@@ -724,23 +874,41 @@ async function pickFreePort(lo, hi, selfPort) {
 	return void 0;
 }
 /**
+
 * Spawn a new `dsh web` instance on a port and decide quickly whether it is
+
 * viable. Detached so it outlives this process. This is intentionally NOT a
+
 * full readiness gate: the wall polls liveness itself, so the create response
+
 * returns fast and a still-booting instance simply shows a pane that lights up
+
 * when the server finishes. A short bounded wait still catches immediate
+
 * spawn failures (bad bin, ENOENT) and very fast boots.
+
 *
+
 * On a genuine launch failure the child is killed so no orphan lingers; on a
+
 * slow-but-viable start the deadline returns ok:true and the child keeps
+
 * booting in the background (the pane already mounted, liveness confirms when
+
 * alive). The child's stderr is captured and quoted into every failure so a
+
 * crash or a bad bin surfaces a concrete reason instead of a bare timeout.
+
 * @param launcher - how to spawn the dsh CLI.
+
 * @param port - the port for the new instance.
+
 * @param timeoutMs - how long to wait before handing back ok:true.
+
 * @param pollMs - readiness probe interval while waiting.
+
 * @returns ok plus the port, or ok:false with a reason.
+
 */
 async function startInstance(launcher, port, timeoutMs = 3e3, pollMs = 300) {
 	const child = spawn(launcher.file, [...launcher.args, String(port)], {
@@ -797,10 +965,15 @@ async function startInstance(launcher, port, timeoutMs = 3e3, pollMs = 300) {
 	}
 }
 /**
+
 * Interface-name patterns that mark a *virtual* NIC (VM bridge, WSL,
+
 * Docker, Hyper-V, VPN adapters, Loopback Pseudo-Instance, etc.). These
+
 * interfaces are never reachable from a phone on the same LAN, so they are
+
 * dropped from the link list entirely.
+
 */
 const VIRTUAL_IFACE_PATTERNS = [
 	/vEthernet/i,
@@ -823,9 +996,13 @@ const VIRTUAL_IFACE_PATTERNS = [
 	/bluetooth/i
 ];
 /**
+
 * Interface-name patterns that mark a *physical* NIC (Wi-Fi / Ethernet).
+
 * Matches kept addresses are ordered before any unknown-but-surviving
+
 * address so the phone-first address is the machine's real NIC.
+
 */
 const PHYSICAL_IFACE_PATTERNS = [
 	/^(wi-?fi|wlan|wireless)/i,
@@ -836,11 +1013,17 @@ const PHYSICAL_IFACE_PATTERNS = [
 	/^w[0-9]+$/i
 ];
 /**
+
 * The non-loopback IPv4 addresses of this machine (the LAN reachable URLs).
+
 * Virtual NICs (VM/WSL/Docker/VPN/loopback pseudo) are filtered out; the
+
 * remaining addresses are ordered with physical NICs (Wi-Fi/Ethernet) first
+
 * so the phone shows the actually-reachable LAN address at the top.
+
 * @returns the address list (possibly empty).
+
 */
 function lanAddresses() {
 	const candidates = [];
@@ -861,11 +1044,17 @@ function lanAddresses() {
 	return candidates.map((c) => c.address);
 }
 /**
+
 * Register the probe routes. Everything lives under `/multi/api` so the
+
 * plugin is purely additive: exact `ports` (auto-discovery) and `status`
+
 * (liveness of a specific port list).
+
 * @param ctx - plugin context carrying the webServer service.
+
 * @param config - validated {@link MultiWallConfig}.
+
 */
 function apply(ctx, config = {}) {
 	const scanFrom = config.scanFrom ?? 3070;

package/lib/invariant.js

@@ -0,0 +1,23 @@
+//#region src/invariant.ts
+const PACKAGE_NAME = "dsh-multi-chat";
+/** Cordis companion plugin name. */
+const name = "dsh-multi-chat-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: the wall contributes the conversation view-ring entry
+* (the wall surface) and the sidebar footer shortcut, whose disposal is
+* proven by the HMR-safety spec — the plugin owns one store handle used by
+* the view entry, emits no cordis events, and holds no cross-plugin mutable
+* state.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+
+//#endregion
+export { apply, inject, name };