super-dsh 0.3.0-e → 0.3.0-g

package/README.md

@@ -22,62 +22,20 @@ six primary `@pgmi-builds/agent-*` packages and three OPTIONAL SDK halves).
 Restart the profile after replacing a loaded package. Each foreign world's
 DSH home is created under `<DSH_HOME>/agents/<label>/` on first boot.
 
-## Better Dash delivery and native Web defaults
-
-Super Dash declares [Better Dash](../better-dsh/) at the synchronized exact
-version in ordinary npm `dependencies`; it contains no Better files or archive.
-One `npm install super-dsh@<version>` or native Plugin Manager installation
-resolves both packages from the configured registry. Publish Better first, then
-Super. Pi's prebuilt SDK dependency tree retains its separate bundled delivery.
-
-DSH does not recursively expose transitive bundles. On startup the coordinator
-registers the already downloaded exact Better version using native profile
-package operations **offline**, without installation hooks or another registry
-fetch. This automatic local registration is separate from the user's single
-installation command. Missing cached data reports a failure instead of falling
-back to online fetching. Replacing loaded code or promoting loaded provenance
-requires the documented cold restart.
-
-The Plugin Manager shows both packages as parallel installed bundles with their
-own YAML and independent switches. Better's Code source is `better-dsh@<version>`.
-Updates retain disablement and same-version explicit uninstall; removing Super
-retains the directly registered Better. Old `bundle-artifacts/` caches are left
-intact for previous installations, but new releases do not write them. With Super
-disabled, registration waits until Super is enabled. dev WebMCP is
-separate and test-only.
-
-Both packages use the same local dual-build pipeline. Tests serve the exact
-unpublished artifact pair through a read-only local registry, without modifying
-the release manifest or preinstalling Better. Current iteration: **0.3.0-f**.
-
-For a tarball URL installation in the native Web UI, put the `.tgz` URL in the
-main Add plugin input and keep the separate Registry selection on the official
-npm registry. A tarball file server is not an npm registry.
-
-Disabling Better restores native Web binding, trusted-host, login and onboarding
-policies. Remote deployments must supply native DSH trusted-host configuration;
-Super does not take ownership of those Better policies.
-
-Better Dash owns the native DSH policies: `dashr-web-trust` retains cookie
-authentication while accepting authenticated serving Host/Origin values; its
-password page provides new-client login. Cookie expiry and authority binding remain.
-`dashr-webserver` defaults to `0.0.0.0`; native `--port` and explicit loopback
-`--host` overrides are preserved. Super Dash carries no duplicate WebTrust.
-To restore the native address fence, set `dashr-web-trust`'s `trustAllHosts: false`.
-
-Better Dash also disables automatic credential onboarding and acknowledges the
-installed Models client's current welcome version before the listener opens.
-Manual model configuration remains available. To restore native welcome behavior:
-
-```yaml
-- id: dashr-welcome-notice
-  disabled: true
-```
+## Better Dash delivery
+
+Super installs [Better Dash](../better-dsh/) at runtime through the native DSH
+Plugin Manager, requesting its installed Super version first, then `better-dsh@latest`, then bare
+`better-dsh` after each preceding failure. The packages have no dependency edge or shared physical payload;
+both retain independent native Plugin Manager rows and component switches.
+
+First-use intent lives under `$DSH_HOME/superd/companions/`, so manual removal
+remains removed across restarts and upgrades. Hub Settings offers explicit
+reinstallation. Both packages ship at synchronized versions; publish Better
+before Super. Pi's prebuilt SDK retains its separate bundled delivery.
 
-Version-only upstream bumps adapt at the next startup. A renamed private constant
-or changed bundle layout fails explicitly and requires adaptation or disabling the
-entry. Dev WebMCP lives in the root `dev-webmcp/` directory and is included
-only as an extra development profile bundle, never in either release tarball.
+Better's welcome policy uses the official client onboarding slot. Native
+WebServer and HMR stay in place; listener configuration belongs to deployment.
 
 ## Runtimes
 

package/client/index.js

@@ -2198,6 +2198,145 @@ async function removeProvider(agentKey, namespace, id, doFetch) {
 	return requireProvidersView(await callRuntimeSettings(agentKey, namespace, "remove", { request: { id } }, doFetch));
 }
 
+//#endregion
+//#region src/client/companion-api.ts
+async function callCompanion(operation, doFetch) {
+	const method = `superdCompanions/${operation}`;
+	const response = await (doFetch ?? ((path, init) => fetch(path, init)))(`/api/${method}`, {
+		method: "POST",
+		credentials: "same-origin",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify({
+			type: "client-request",
+			rpcId: mintRpcId(),
+			method,
+			payload: { args: {} }
+		})
+	});
+	if (!response.ok) throw new Error(`Better Dash: HTTP ${response.status}`);
+	let body;
+	try {
+		body = JSON.parse(await response.text());
+	} catch {
+		throw new Error("Better Dash: unreadable response");
+	}
+	const result = body?.result;
+	if (result?.ok !== true) throw new Error(result?.error?.message ?? "Better Dash: request failed");
+	const value = result.value;
+	if (value === null || typeof value !== "object" || typeof value.installed !== "boolean" || typeof value.installing !== "boolean" || typeof value.requestedVersion !== "string" || value.version !== void 0 && typeof value.version !== "string" || value.enabled !== void 0 && typeof value.enabled !== "boolean" || value.error !== void 0 && typeof value.error !== "string") throw new Error("Better Dash: invalid status");
+	return value;
+}
+
+//#endregion
+//#region src/client/CompanionSettings.tsx
+/** Native plugin switches remain in Plugin Manager; this row provides explicit recovery. */
+function CompanionSettings() {
+	const [status, setStatus] = react.default.useState();
+	const [error, setError] = react.default.useState();
+	const [busy, setBusy] = react.default.useState(false);
+	const live = react.default.useRef(false);
+	const operation = react.default.useRef(false);
+	react.default.useEffect(() => {
+		live.current = true;
+		let reading = false;
+		const refresh = async () => {
+			if (reading || operation.current) return;
+			reading = true;
+			try {
+				const next = await callCompanion("getBetterDash");
+				if (live.current) {
+					setStatus(next);
+					setError(next.error);
+				}
+			} catch (cause) {
+				if (live.current) setError(cause instanceof Error ? cause.message : String(cause));
+			} finally {
+				reading = false;
+			}
+		};
+		refresh();
+		const timer = window.setInterval(() => {
+			refresh();
+		}, 5e3);
+		return () => {
+			live.current = false;
+			window.clearInterval(timer);
+		};
+	}, []);
+	const install = async () => {
+		if (operation.current) return;
+		operation.current = true;
+		setBusy(true);
+		setError(void 0);
+		try {
+			const next = await callCompanion("installBetterDash");
+			if (live.current) {
+				setStatus(next);
+				setError(next.error);
+			}
+		} catch (cause) {
+			if (live.current) setError(cause instanceof Error ? cause.message : String(cause));
+		} finally {
+			operation.current = false;
+			if (live.current) setBusy(false);
+		}
+	};
+	const installing = busy || status?.installing === true;
+	const label = status === void 0 ? "Loading…" : status.installed ? `Installed${status.version ? " · " + status.version : ""}${status.enabled === false ? " · Disabled" : ""}` : "Not installed";
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+		style: {
+			borderRadius: 12,
+			padding: "12px 14px",
+			background: "var(--dsw-alias-interactive-bg-hover)"
+		},
+		children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+			style: {
+				display: "flex",
+				alignItems: "center",
+				gap: 16
+			},
+			children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: { flex: 1 },
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+					style: {
+						fontSize: 14,
+						fontWeight: 600
+					},
+					children: "Better Dash"
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+					role: "status",
+					style: {
+						fontSize: 12,
+						color: "var(--dsw-alias-label-secondary)",
+						marginTop: 4
+					},
+					children: installing ? "Installing…" : label
+				})]
+			}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+				type: "button",
+				disabled: installing || status?.installed === true,
+				onClick: () => {
+					install();
+				},
+				style: {
+					padding: "6px 12px",
+					borderRadius: 8,
+					cursor: installing || status?.installed ? "default" : "pointer"
+				},
+				children: installing ? "Installing…" : status?.installed ? "Installed" : "Install"
+			})]
+		}), error && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+			role: "alert",
+			style: {
+				fontSize: 12,
+				margin: "8px 0 0",
+				color: "var(--dsw-alias-state-error-primary)"
+			},
+			children: error
+		})]
+	});
+}
+
 //#endregion
 //#region src/client/HubPage.tsx
 const EMPTY_DRAFT = {
@@ -3415,16 +3554,8 @@ function HubPage() {
 					},
 					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(GroupHead, {
 						title: "Settings",
-						count: 0
-					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
-						style: {
-							margin: 0,
-							fontSize: 13,
-							lineHeight: "20px",
-							color: "var(--dsw-alias-label-tertiary)"
-						},
-						children: "Hub preferences — pairing, runtime visibility, and orchestration defaults land with the hub service."
-					})]
+						count: 1
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CompanionSettings, {})]
 				}),
 				tab === "home" && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("section", {
 					style: {

package/cordis.patch.yml

@@ -12,8 +12,8 @@
 #                              zero-port sibling root, mounted under /<label>
 #   - super-dsh/join           the generic hub joiner for the standalone
 #                              claude adapter (R2)
-# DSH-only WebTrust, WebServer and onboarding policies belong to the exact registry
-# Better Dash dependency, registered as an independent profile bundle.
+# DSH-only WebTrust and onboarding policies belong to independently installed
+# Better Dash; the native Plugin Manager owns its package and enablement.
 #   - super-dsh/a2a            the agent-facing A2A tool face (mesh P3): the
 #                              single `superd-hub` model tool on ctx0's tools
 #                              service (dormant without tools; world trees
@@ -22,7 +22,7 @@
 # Profile-layer values (webserver port/host, settings path) stay in the USER's
 # profile patch layer, never here.
 - insert:
-    # Register the already installed exact registry companion as an independent native bundle.
+    # Expose native companion management and perform first-use installation.
     - id: superd-bundle-setup
       name: 'super-dsh/setup'
     # BARE package row: subpath rows (…/agents/omp) are permanently not client
@@ -51,6 +51,9 @@
     # get their own injection in P5, spec §10). Dormant without tools.
     # Off: restate with `disabled: true` or drop the row — nothing else
     # registers the tool.
+    # Independent build of Better's canonical remote source; default-on per Agent.
+    - id: superd-remote
+      name: 'super-dsh/remote'
     - id: superd-a2a
       name: 'super-dsh/a2a'
     - id: agent-omp

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "super-dsh",
-  "version": "0.3.0-e",
+  "version": "0.3.0-g",
   "description": "Super D for the DeepSeek Harness (DSH) — one dsh plugin that mounts the superd hub (runtime selector, roster, per-runtime agents) and joins local foreign-agent runtimes (OMP, Codex, Claude, Pi, Hermes, Antigravity) into the DSH Web UI. Each runtime keeps its native home and session store; the hub only bridges.",
   "type": "module",
   "license": "MIT",
@@ -27,7 +27,11 @@
     "./package.json": "./package.json",
     "./fusion-transport": "./superd-hub/dist/fusion-transport.js",
     "./a2a": "./superd-hub/dist/a2a-row.js",
-    "./setup": "./superd-hub/dist/bundle-setup.js"
+    "./setup": "./superd-hub/dist/bundle-setup.js",
+    "./remote": {
+      "types": "./remote/plugin.d.ts",
+      "default": "./remote/plugin.js"
+    }
   },
   "files": [
     "cordis.patch.yml",
@@ -69,7 +73,7 @@
     "agent-agy-sdk/package.json",
     "agent-agy-sdk/cordis.patch.yml",
     "agent-agy-sdk/bridge",
-    "superd-hub/scripts/register-companion.mjs"
+    "remote"
   ],
   "dsh": {
     "bundle": {
@@ -83,7 +87,6 @@
     }
   },
   "dependencies": {
-    "better-dsh": "0.3.0-e",
     "@earendil-works/pi-coding-agent": "0.84.2",
     "zod": "4.4.3",
     "@modelcontextprotocol/sdk": "^1.29.0"
@@ -108,7 +111,8 @@
     "@deepseek-ai/dsh-app-boot": ">=0.1.5-0 <0.3.0-0",
     "@deepseek-ai/dsh-atomic-write": ">=0.1.5-0 <0.3.0-0",
     "@deepseek-ai/dsh-cmdline": ">=0.1.5-0 <0.3.0-0",
-    "@deepseek-ai/dsh-plugin-manager": ">=0.1.5-0 <0.3.0-0"
+    "@deepseek-ai/dsh-plugin-manager": ">=0.1.5-0 <0.3.0-0",
+    "@deepseek-ai/dsh-jobs": ">=0.1.5-0 <0.3.0-0"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/cordis": {
@@ -170,6 +174,9 @@
     },
     "@deepseek-ai/dsh-plugin-manager": {
       "optional": true
+    },
+    "@deepseek-ai/dsh-jobs": {
+      "optional": true
     }
   },
   "publishConfig": {

package/remote/file-worker.js

@@ -0,0 +1,341 @@
+import { constants, createReadStream, createWriteStream, mkdirSync } from "node:fs";
+import { pipeline } from "node:stream/promises";
+import { lstat, mkdir, mkdtemp, open, readdir, readlink, rename, rm, symlink } from "node:fs/promises";
+import { Readable } from "node:stream";
+import { createHash, randomUUID } from "node:crypto";
+import { tmpdir } from "node:os";
+import { dirname, join, posix, resolve } from "node:path";
+
+//#region src/remote/archive.ts
+const FILE_FRAME_BYTES = 64 * 1024;
+const FILE_MAX_ENTRIES = 1e4;
+const FILE_MAX_METADATA = 8 * 1024 * 1024;
+const order = (a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b));
+function checkRelative(p) {
+	if (typeof p !== "string" || Buffer.byteLength(p) > 4096 || p.includes("\0") || p !== "" && (p.startsWith("/") || p.split("/").some((s) => !s || s === "." || s === ".."))) throw new Error("unsafe archive relative path");
+}
+function checkAbsolute(p) {
+	if (typeof p !== "string" || !p.startsWith("/") || p.includes("\0") || p.split("/").includes("..")) throw new Error("file endpoint requires an absolute path without traversal or NUL");
+}
+function checkSelection(selection) {
+	if (selection.length > FILE_MAX_ENTRIES || Buffer.byteLength(JSON.stringify(selection)) > FILE_MAX_METADATA) throw new Error("file selection metadata limit exceeded");
+	const seen = /* @__PURE__ */ new Set();
+	for (const p of selection) {
+		checkRelative(p);
+		if (seen.has(p)) throw new Error("duplicate selection path");
+		seen.add(p);
+	}
+}
+function checkLink(e) {
+	const link = e.link;
+	if (e.p === "" || typeof link !== "string" || !link || link.includes("\0") || link.startsWith("/") || Buffer.byteLength(link) > 4096) throw new Error("unsafe archive symlink");
+	const target = posix.normalize(posix.join(posix.dirname(e.p), link));
+	if (target === ".." || target.startsWith("../")) throw new Error("unsafe archive symlink escape");
+}
+/** Conservative effective resolution: links may traverse only members of this incoming tree.
+* Preserved destination extras cannot supply a symlink target or any of its ancestors.
+*/
+function checkTreeLinks(entries) {
+	const incoming = new Map(entries.map((e) => [e.p, e]));
+	for (const link of entries.filter((e) => e.t === "l")) {
+		const stack = posix.dirname(link.p) === "." ? [] : posix.dirname(link.p).split("/");
+		let pending = link.link.split("/"), hops = 0;
+		while (pending.length) {
+			const part = pending.shift();
+			if (!part || part === ".") continue;
+			if (part === "..") {
+				if (!stack.length) throw new Error("unsafe symlink chain escape");
+				stack.pop();
+				continue;
+			}
+			const entry = incoming.get([...stack, part].join("/"));
+			if (!entry) throw new Error("unsafe symlink target outside incoming tree (destination aliases are not followed)");
+			if (entry.t === "l") {
+				if (++hops > 40) throw new Error("unsafe symlink cycle or chain limit");
+				pending = [...entry.link.split("/"), ...pending];
+			} else {
+				if (pending.length && entry.t !== "d") throw new Error("unsafe symlink non-directory target ancestor");
+				stack.push(part);
+			}
+		}
+	}
+}
+function header(e) {
+	const b = Buffer.from(JSON.stringify(e)), n = Buffer.alloc(4);
+	n.writeUInt32BE(b.length);
+	return Buffer.concat([n, b]);
+}
+function manifestDigest(entries) {
+	const hash = createHash("sha256");
+	let bytes = 0;
+	for (const e of [...entries].sort((a, b) => order(a.p, b.p))) {
+		hash.update(header([
+			e.p,
+			e.t,
+			e.n,
+			e.t === "f" ? e.hash : e.t === "l" ? e.link : ""
+		]));
+		if (e.t === "f") bytes += e.n;
+	}
+	return {
+		sha256: hash.digest("hex"),
+		bytes,
+		entries: entries.length
+	};
+}
+/** Reject even existing parent symlinks; leaf may be an explicitly copied symlink. */
+async function ancestors(path, includeLeaf = false) {
+	checkAbsolute(path);
+	const parts = resolve(path).split("/").filter(Boolean);
+	for (let i = 1; i <= parts.length - (includeLeaf ? 0 : 1); i++) try {
+		const st = await lstat("/" + parts.slice(0, i).join("/"));
+		if (st.isSymbolicLink() || !st.isDirectory()) throw new Error("unsafe destination/source ancestor: symlink or non-directory");
+	} catch (e) {
+		if (e.code !== "ENOENT") throw e;
+	}
+}
+async function safeRead(path, signal) {
+	return (await open(path, constants.O_RDONLY | constants.O_NOFOLLOW)).createReadStream({
+		autoClose: true,
+		highWaterMark: FILE_FRAME_BYTES,
+		signal
+	});
+}
+async function entryAt(root, p, signal) {
+	signal.throwIfAborted();
+	const path = p ? join(root, p) : root;
+	await ancestors(path);
+	const st = await lstat(path);
+	if (st.isDirectory()) return {
+		p,
+		t: "d",
+		n: 0
+	};
+	if (st.isSymbolicLink()) {
+		const e = {
+			p,
+			t: "l",
+			n: 0,
+			link: await readlink(path)
+		};
+		checkLink(e);
+		return e;
+	}
+	if (!st.isFile()) throw new Error("unsupported file type (only files, directories and safe relative symlinks)");
+	const hash = createHash("sha256");
+	for await (const chunk of await safeRead(path, signal)) hash.update(chunk);
+	return {
+		p,
+		t: "f",
+		n: st.size,
+		hash: hash.digest("hex")
+	};
+}
+async function tree(root, signal, selection) {
+	checkAbsolute(root);
+	const entries = [];
+	const visit = async (p) => {
+		const e = await entryAt(root, p, signal);
+		entries.push(e);
+		if (entries.length > FILE_MAX_ENTRIES) throw new Error("archive entry limit exceeded");
+		if (e.t === "d") for (const name of (await readdir(p ? join(root, p) : root)).sort(order)) await visit(p ? `${p}/${name}` : name);
+	};
+	if (selection) {
+		checkSelection(selection);
+		for (const p of selection) entries.push(await entryAt(root, p, signal));
+	} else await visit("");
+	if (Buffer.byteLength(JSON.stringify(entries)) > FILE_MAX_METADATA) throw new Error("archive metadata limit exceeded");
+	return entries;
+}
+async function inspectArchive(path, signal) {
+	const file = await open(path, "r");
+	let offset = 0, metadata = 0;
+	const entries = [];
+	const seen = /* @__PURE__ */ new Map();
+	const exact = async (n) => {
+		const b = Buffer.alloc(n);
+		let at = 0;
+		while (at < n) {
+			signal.throwIfAborted();
+			const r = await file.read(b, at, n - at, offset);
+			if (!r.bytesRead) throw new Error("truncated binary archive");
+			at += r.bytesRead;
+			offset += r.bytesRead;
+		}
+		return b;
+	};
+	try {
+		while (true) {
+			const size = (await exact(4)).readUInt32BE();
+			if (!size || size > FILE_FRAME_BYTES) throw new Error("archive header limit exceeded");
+			metadata += size;
+			if (metadata > FILE_MAX_METADATA) throw new Error("archive metadata limit exceeded");
+			const e = JSON.parse((await exact(size)).toString("utf8"));
+			if (e.end === true) {
+				if ((await file.stat()).size !== offset) throw new Error("trailing archive bytes");
+				break;
+			}
+			checkRelative(e.p);
+			if (![
+				"f",
+				"d",
+				"l"
+			].includes(e.t) || !Number.isSafeInteger(e.n) || e.n < 0 || e.t !== "f" && e.n !== 0) throw new Error("unsafe archive type/size");
+			if (entries.length >= FILE_MAX_ENTRIES || seen.has(e.p)) throw new Error("archive entry limit or duplicate path");
+			if (e.p !== "" && seen.get(posix.dirname(e.p) === "." ? "" : posix.dirname(e.p))?.t !== "d") throw new Error("unsafe archive parent ordering/type");
+			if (!entries.length && e.p !== "") throw new Error("archive root missing");
+			if (e.t === "l") checkLink(e);
+			e.offset = offset;
+			if (e.t === "f") {
+				const hash = createHash("sha256");
+				let left = e.n;
+				while (left) {
+					const chunk = await exact(Math.min(FILE_FRAME_BYTES, left));
+					hash.update(chunk);
+					left -= chunk.length;
+				}
+				e.hash = hash.digest("hex");
+			}
+			entries.push(e);
+			seen.set(e.p, e);
+		}
+		if (!entries.length) throw new Error("archive root missing");
+		return entries;
+	} finally {
+		await file.close();
+	}
+}
+async function importArchive(destination, payload, mkdirParents, signal, resources) {
+	checkAbsolute(destination);
+	const entries = await inspectArchive(payload, signal);
+	checkTreeLinks(entries);
+	for (const e of entries) {
+		const path = e.p ? join(destination, e.p) : destination;
+		await ancestors(path);
+		try {
+			const st = await lstat(path);
+			const type = st.isSymbolicLink() ? "l" : st.isDirectory() ? "d" : st.isFile() ? "f" : "?";
+			if (type !== e.t || type === "l") throw new Error("destination path/type conflict or existing symlink");
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+	}
+	await ancestors(destination);
+	if (mkdirParents) await mkdir(dirname(destination), { recursive: true });
+	for (const e of entries) {
+		signal.throwIfAborted();
+		const path = e.p ? join(destination, e.p) : destination;
+		await ancestors(path);
+		if (e.t === "d") {
+			await mkdir(path, { recursive: false }).catch((error) => {
+				if (error.code !== "EEXIST") throw error;
+			});
+			continue;
+		}
+		if (e.t === "l") {
+			await symlink(e.link, path);
+			continue;
+		}
+		const temporary = join(dirname(path), `.remote-copy-${randomUUID()}`);
+		await resources.temporary?.(temporary, true);
+		try {
+			const output = createWriteStream(temporary, {
+				flags: "wx",
+				mode: 384
+			});
+			await pipeline(e.n ? createReadStream(payload, {
+				start: e.offset,
+				end: e.offset + e.n - 1
+			}) : Readable.from([]), output, { signal });
+			await ancestors(path);
+			signal.throwIfAborted();
+			await rename(temporary, path);
+		} finally {
+			await rm(temporary, { force: true });
+			await resources.temporary?.(temporary, false);
+		}
+	}
+}
+function localFileEndpoint(resources = {}) {
+	return {
+		async exportTree(path, signal) {
+			const entries = await tree(path, signal);
+			return Readable.from((async function* () {
+				for (const e of entries) {
+					signal.throwIfAborted();
+					yield header({
+						p: e.p,
+						t: e.t,
+						n: e.n,
+						...e.link === void 0 ? {} : { link: e.link }
+					});
+					if (e.t === "f" && e.n) for await (const chunk of await safeRead(e.p ? join(path, e.p) : path, signal)) yield chunk;
+				}
+				yield header({ end: true });
+			})());
+		},
+		async importTree(path, source, { mkdir: parents, signal }) {
+			checkAbsolute(path);
+			const scratch = resources.receiveRoot ?? await mkdtemp(join(tmpdir(), "remote-file-receive-"));
+			try {
+				const payload = join(scratch, "payload");
+				await pipeline(source, createWriteStream(payload, {
+					flags: "wx",
+					mode: 384
+				}), { signal });
+				await importArchive(path, payload, parents, signal, resources);
+			} finally {
+				source.destroy?.();
+				await rm(scratch, {
+					recursive: true,
+					force: true
+				});
+			}
+		},
+		async digest(path, signal, selection) {
+			return manifestDigest(await tree(path, signal, selection));
+		}
+	};
+}
+
+//#endregion
+//#region src/remote/file-worker.ts
+async function runFileWorker(request) {
+	const abort = new AbortController(), cancel = () => abort.abort(/* @__PURE__ */ new Error("binary file worker cancelled"));
+	process.on("SIGTERM", cancel);
+	process.on("SIGHUP", cancel);
+	const report = (value) => new Promise((resolve$1, reject) => process.stderr.write(JSON.stringify(value) + "\n", (error) => error ? reject(error) : resolve$1()));
+	try {
+		mkdirSync(request.root, { mode: 448 });
+		const endpoint = localFileEndpoint({
+			receiveRoot: request.root,
+			temporary: (path, active) => report({
+				temporary: path,
+				active
+			})
+		});
+		if (request.action === "export") await pipeline(await endpoint.exportTree(request.path, abort.signal), process.stdout, { signal: abort.signal });
+		else if (request.action === "import") await endpoint.importTree(request.path, process.stdin, {
+			mkdir: request.mkdir,
+			signal: abort.signal
+		});
+		else {
+			let metadata = "";
+			process.stdin.setEncoding("utf8");
+			for await (const chunk of process.stdin) {
+				metadata += String(chunk);
+				if (Buffer.byteLength(metadata) > FILE_MAX_METADATA) throw new Error("file selection metadata limit exceeded");
+			}
+			process.stdout.write(JSON.stringify(await endpoint.digest(request.path, abort.signal, request.selected ? JSON.parse(metadata) : void 0)));
+		}
+	} catch (error) {
+		await report({ error: error instanceof Error ? error.message : String(error) }).catch(() => {});
+		process.exitCode = 1;
+	} finally {
+		process.removeListener("SIGTERM", cancel);
+		process.removeListener("SIGHUP", cancel);
+	}
+}
+
+//#endregion
+export { runFileWorker };