dsh-plugin-workbench 0.0.4 → 0.0.6

package/lib/index.js

@@ -1,10 +1,51 @@
+import { spawn } from "node:child_process";
+import { watch } from "node:fs";
+import { basename, dirname } from "node:path";
+import { cp, mkdir, rename, rm, writeFile } from "node:fs/promises";
 //#region src/index.ts
 const name = "dsh-plugin-workbench";
-const inject = ["fs", "connection"];
+const inject = [
+	"fs",
+	"connection",
+	"webServer"
+];
 /** Loopback-only logical RPC channel. */
 const CHANNEL = "/dsh-plugin-files";
 /** Files larger than this are never read for preview (client shows size + hint). */
 const MAX_PREVIEW_BYTES = 524288;
+/** Same-origin route serving raw bytes for image files (see module doc). */
+const RAW_PREFIX = "/dsh-plugin-files/raw";
+/** Same-origin SSE route streaming disk-change events to the preview pane. */
+const EVENTS_PREFIX = "/dsh-plugin-files/events";
+/** Images larger than this are never served to the preview (browser shows a hint). */
+const MAX_IMAGE_BYTES = 20971520;
+/** Coalesce bursty editor writes into a single change notification. */
+const WATCH_DEBOUNCE_MS = 300;
+/** Ignore fs.watch events caused by this plugin's own saves (see module doc). */
+const SELF_WRITE_WINDOW_MS = 1500;
+/** SSE keep-alive interval (proxies may otherwise drop idle connections). */
+const SSE_HEARTBEAT_MS = 15e3;
+const IMAGE_MIME = {
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	webp: "image/webp",
+	avif: "image/avif",
+	bmp: "image/bmp",
+	ico: "image/x-icon",
+	svg: "image/svg+xml"
+};
+/** MIME type for a path's extension when it names a previewable image; undefined otherwise. */
+function imageMimeOf(path) {
+	const idx = path.lastIndexOf(".");
+	if (idx < 0 || idx === path.length - 1) return void 0;
+	return IMAGE_MIME[path.slice(idx + 1).toLowerCase()];
+}
+/** True when the path names a previewable image file. */
+function isImagePath(path) {
+	return imageMimeOf(path) !== void 0;
+}
 /** Map an fs entry type onto the wire `kind` union. */
 function kindOf(type) {
 	if (type === "directory") return "dir";
@@ -42,7 +83,15 @@ const FS_ERROR_MESSAGES = {
 	FS_PERMISSION_DENIED: "permission denied",
 	FS_SANDBOX_DENIED: "sandbox denied",
 	FS_ABORTED: "aborted",
-	FS_IO_ERROR: "io error"
+	FS_IO_ERROR: "io error",
+	EEXIST: "file or folder already exists",
+	ENOENT: "path does not exist",
+	ENOTEMPTY: "folder is not empty",
+	EPERM: "permission denied",
+	EACCES: "permission denied",
+	ENOTDIR: "not a directory",
+	EISDIR: "is a directory",
+	EBUSY: "file is in use"
 };
 /** Human-readable message for a thrown value, honoring the fs error code taxonomy. */
 function mapError(error) {
@@ -77,13 +126,232 @@ function pathOf(payload) {
 * cancels the underlying fs call (or aborts between steps).
 */
 function apply(ctx) {
+	const watchState = {
+		dirs: /* @__PURE__ */ new Map(),
+		files: /* @__PURE__ */ new Map(),
+		selfWrites: /* @__PURE__ */ new Map(),
+		clients: /* @__PURE__ */ new Set()
+	};
 	const handler = async (endpoint, payload, signal) => {
 		if (endpoint === "list") return listDir(ctx, payload, signal);
 		if (endpoint === "read") return readFile(ctx, payload, signal);
-		if (endpoint === "write") return writeFile(ctx, payload, signal);
+		if (endpoint === "write") return writeFile$1(ctx, watchState, payload, signal);
+		if (endpoint === "watch") return setWatch(ctx, watchState, payload, signal);
+		if (endpoint === "createFile") return createFile(ctx, payload, signal);
+		if (endpoint === "createDir") return createDir(ctx, payload, signal);
+		if (endpoint === "rename") return renameEntry(ctx, payload, signal);
+		if (endpoint === "delete") return deleteEntry(ctx, payload, signal);
+		if (endpoint === "copy") return copyEntry(ctx, payload, signal);
+		if (endpoint === "reveal") return revealInExplorer(ctx, payload, signal);
 		return fail(`unknown endpoint: ${endpoint}`);
 	};
-	ctx.connection.rpc.handle(CHANNEL, handler, { authority: "loopback" });
+	ctx.effect(() => ctx.connection.rpc.handle(CHANNEL, handler, { authority: "loopback" }), "dsh-plugin-workbench: files rpc channel");
+	ctx.effect(() => ctx.webServer.register({
+		kind: "prefix",
+		path: RAW_PREFIX,
+		handler: (req, res) => {
+			serveRaw(ctx, req, res);
+		}
+	}), "dsh-plugin-workbench: raw image route");
+	ctx.effect(() => {
+		const disposeRoute = ctx.webServer.register({
+			kind: "exact",
+			path: EVENTS_PREFIX,
+			handler: (req, res) => sseHandler(watchState, req, res)
+		});
+		const heartbeat = setInterval(() => {
+			for (const res of watchState.clients) try {
+				res.write(": ping\n\n");
+			} catch {}
+		}, SSE_HEARTBEAT_MS);
+		return () => {
+			clearInterval(heartbeat);
+			disposeRoute();
+			disposeWatch(watchState);
+		};
+	}, "dsh-plugin-workbench: disk change stream (SSE)");
+}
+/** Serve one SSE client connection (kept open until the browser disconnects). */
+function sseHandler(state, req, res) {
+	if ((req.method ?? "GET").toUpperCase() !== "GET") {
+		res.writeHead(405, { "content-type": "text/plain; charset=utf-8" });
+		res.end("method not allowed");
+		return;
+	}
+	res.writeHead(200, {
+		"content-type": "text/event-stream",
+		"cache-control": "no-cache",
+		connection: "keep-alive",
+		"x-accel-buffering": "no"
+	});
+	res.write(": connected\n\n");
+	state.clients.add(res);
+	req.on("close", () => {
+		state.clients.delete(res);
+	});
+}
+/** Push one `change` frame to every connected SSE client. */
+function emitChange(state, path) {
+	const frame = `event: change\ndata: ${JSON.stringify({ path })}\n\n`;
+	for (const res of state.clients) try {
+		res.write(frame);
+	} catch {}
+}
+/**
+* Coalesce one filesystem event for an osPath into a single change
+* notification (editors emit several events per save; the debounce collapses
+* them). Events caused by this plugin's own saves are suppressed.
+*/
+function scheduleEmit(state, osPath) {
+	const entry = state.files.get(osPath);
+	if (entry === void 0) return;
+	const selfTs = state.selfWrites.get(osPath);
+	if (selfTs !== void 0 && Date.now() - selfTs < SELF_WRITE_WINDOW_MS) return;
+	if (entry.timer !== void 0) clearTimeout(entry.timer);
+	entry.timer = setTimeout(() => {
+		entry.timer = void 0;
+		const still = state.files.get(osPath);
+		if (still === void 0) return;
+		emitChange(state, still.path);
+	}, WATCH_DEBOUNCE_MS);
+}
+/** Start (or extend) the parent-dir watcher covering osPath. */
+function watchDir(state, dir, osPath) {
+	let bucket = state.dirs.get(dir);
+	if (bucket === void 0) {
+		let watcher;
+		try {
+			watcher = watch(dir, { persistent: false }, (_eventType, filename) => {
+				const name = typeof filename === "string" ? filename : void 0;
+				if (name === void 0) {
+					for (const os of state.files.keys()) if (dirname(os) === dir) scheduleEmit(state, os);
+					return;
+				}
+				const targets = state.dirs.get(dir)?.basenames.get(name);
+				if (targets === void 0) return;
+				for (const os of targets) scheduleEmit(state, os);
+			});
+		} catch {
+			return false;
+		}
+		bucket = {
+			watcher,
+			basenames: /* @__PURE__ */ new Map()
+		};
+		state.dirs.set(dir, bucket);
+	}
+	const name = basename(osPath);
+	let targets = bucket.basenames.get(name);
+	if (targets === void 0) {
+		targets = /* @__PURE__ */ new Set();
+		bucket.basenames.set(name, targets);
+	}
+	targets.add(osPath);
+	return true;
+}
+/** Stop watching one osPath (and its parent dir when nothing else uses it). */
+function unwatch(state, osPath) {
+	const entry = state.files.get(osPath);
+	if (entry === void 0) return;
+	if (entry.timer !== void 0) clearTimeout(entry.timer);
+	state.files.delete(osPath);
+	state.selfWrites.delete(osPath);
+	const dir = dirname(osPath);
+	const bucket = state.dirs.get(dir);
+	if (bucket === void 0) return;
+	const name = basename(osPath);
+	const targets = bucket.basenames.get(name);
+	if (targets !== void 0) {
+		targets.delete(osPath);
+		if (targets.size === 0) bucket.basenames.delete(name);
+	}
+	if (bucket.basenames.size === 0) {
+		bucket.watcher.close();
+		state.dirs.delete(dir);
+	}
+}
+/** Close every watcher, pending timer and SSE client (effect disposal). */
+function disposeWatch(state) {
+	for (const bucket of state.dirs.values()) bucket.watcher.close();
+	state.dirs.clear();
+	for (const entry of state.files.values()) if (entry.timer !== void 0) clearTimeout(entry.timer);
+	state.files.clear();
+	state.selfWrites.clear();
+	for (const res of state.clients) try {
+		res.end();
+	} catch {}
+	state.clients.clear();
+}
+/** Reconcile the watcher set with the client's open tab paths (idempotent). */
+async function setWatch(ctx, state, payload, signal) {
+	const raw = typeof payload === "object" && payload !== null ? payload.paths : void 0;
+	if (!Array.isArray(raw) || raw.some((p) => typeof p !== "string")) return fail("watch: payload.paths must be an array of strings");
+	const wanted = /* @__PURE__ */ new Map();
+	for (const p of raw) {
+		if (signal.aborted) break;
+		try {
+			const target = await ctx.fs.resolve(p, { signal });
+			const osPath = ctx.fs.processPath(target);
+			wanted.set(osPath, p);
+		} catch {}
+	}
+	for (const osPath of [...state.files.keys()]) if (!wanted.has(osPath)) unwatch(state, osPath);
+	for (const [osPath, displayPath] of wanted) {
+		if (state.files.has(osPath)) continue;
+		if (!watchDir(state, dirname(osPath), osPath)) continue;
+		state.files.set(osPath, {
+			path: displayPath,
+			timer: void 0
+		});
+	}
+	return {
+		ok: true,
+		value: { path: "" }
+	};
+}
+async function serveRaw(ctx, req, res) {
+	const text = (code, body) => {
+		res.writeHead(code, { "content-type": "text/plain; charset=utf-8" });
+		res.end(body);
+	};
+	try {
+		if ((req.method ?? "GET").toUpperCase() !== "GET") {
+			text(405, "method not allowed");
+			return;
+		}
+		const rest = new URL(req.url ?? "/", "http://dsh.internal").pathname.slice(21).replace(/^\/+/, "");
+		if (rest.length === 0) {
+			text(404, "not found");
+			return;
+		}
+		const path = decodeURIComponent(rest);
+		const mime = imageMimeOf(path);
+		if (mime === void 0) {
+			text(404, "not an image");
+			return;
+		}
+		const target = await ctx.fs.resolve(path);
+		const info = await ctx.fs.stat(target);
+		if (info === void 0 || info.type !== "file") {
+			text(404, "not found");
+			return;
+		}
+		if ((info.size ?? 0) > 20971520) {
+			text(413, "image too large");
+			return;
+		}
+		const bytes = await ctx.fs.readBytes(target, void 0, MAX_IMAGE_BYTES);
+		res.writeHead(200, {
+			"content-type": mime,
+			"content-length": bytes.byteLength,
+			"cache-control": "private, max-age=300",
+			"x-content-type-options": "nosniff"
+		});
+		res.end(Buffer.from(bytes));
+	} catch (error) {
+		if (!res.headersSent) text(500, "internal error");
+		else res.destroy();
+	}
 }
 async function listDir(ctx, payload, signal) {
 	const path = pathOf(payload);
@@ -153,7 +421,7 @@ async function readFile(ctx, payload, signal) {
 		return fail(mapError(error));
 	}
 }
-async function writeFile(ctx, payload, signal) {
+async function writeFile$1(ctx, state, payload, signal) {
 	const path = pathOf(payload);
 	const content = typeof payload === "object" && payload !== null ? payload.content : void 0;
 	if (path === void 0) return fail("write: payload.path must be a non-empty string");
@@ -164,10 +432,16 @@ async function writeFile(ctx, payload, signal) {
 			mode: "danger-full-access",
 			workspaceRoot: ctx.fs.processPath(target)
 		});
+		const osPath = ctx.fs.processPath(target);
+		state.selfWrites.set(osPath, Date.now());
+		if (state.selfWrites.size > 64) {
+			const cutoff = Date.now() - SELF_WRITE_WINDOW_MS * 4;
+			for (const [os, ts] of state.selfWrites) if (ts < cutoff) state.selfWrites.delete(os);
+		}
 		return {
 			ok: true,
 			value: {
-				path: ctx.fs.processPath(target),
+				path: osPath,
 				size: content.length
 			}
 		};
@@ -175,5 +449,191 @@ async function writeFile(ctx, payload, signal) {
 		return fail(mapError(error));
 	}
 }
+async function createFile(ctx, payload, signal) {
+	const path = pathOf(payload);
+	if (path === void 0) return fail("createFile: payload.path must be a non-empty string");
+	try {
+		const target = await ctx.fs.resolve(path, { signal });
+		const osPath = ctx.fs.processPath(target);
+		await writeFile(osPath, "", { flag: "wx" });
+		return {
+			ok: true,
+			value: { path: osPath }
+		};
+	} catch (error) {
+		return fail(mapError(error));
+	}
+}
+async function createDir(ctx, payload, signal) {
+	const path = pathOf(payload);
+	if (path === void 0) return fail("createDir: payload.path must be a non-empty string");
+	try {
+		const target = await ctx.fs.resolve(path, { signal });
+		const osPath = ctx.fs.processPath(target);
+		await mkdir(osPath);
+		return {
+			ok: true,
+			value: { path: osPath }
+		};
+	} catch (error) {
+		return fail(mapError(error));
+	}
+}
+async function renameEntry(ctx, payload, signal) {
+	const path = pathOf(payload);
+	const to = typeof payload === "object" && payload !== null ? payload.to : void 0;
+	if (path === void 0) return fail("rename: payload.path must be a non-empty string");
+	if (typeof to !== "string" || to.trim().length === 0) return fail("rename: payload.to must be a non-empty string");
+	try {
+		const target = await ctx.fs.resolve(path, { signal });
+		const osPath = ctx.fs.processPath(target);
+		const toTarget = await ctx.fs.resolve(to, { signal });
+		const toOsPath = ctx.fs.processPath(toTarget);
+		if (await ctx.fs.stat(toTarget, signal) !== void 0) return fail("rename: destination already exists");
+		await rename(osPath, toOsPath);
+		return {
+			ok: true,
+			value: { path: toOsPath }
+		};
+	} catch (error) {
+		return fail(mapError(error));
+	}
+}
+async function deleteEntry(ctx, payload, signal) {
+	const path = pathOf(payload);
+	if (path === void 0) return fail("delete: payload.path must be a non-empty string");
+	try {
+		const target = await ctx.fs.resolve(path, { signal });
+		const osPath = ctx.fs.processPath(target);
+		const info = await ctx.fs.stat(target, signal);
+		if (info === void 0) return fail(`path not found: ${path}`);
+		await rm(osPath, {
+			recursive: info.type === "directory",
+			force: true
+		});
+		return {
+			ok: true,
+			value: { path: osPath }
+		};
+	} catch (error) {
+		return fail(mapError(error));
+	}
+}
+async function copyEntry(ctx, payload, signal) {
+	const from = typeof payload === "object" && payload !== null ? payload.from : void 0;
+	const to = typeof payload === "object" && payload !== null ? payload.to : void 0;
+	const overwrite = typeof payload === "object" && payload !== null && payload.overwrite === true;
+	if (typeof from !== "string" || from.trim().length === 0) return fail("copy: payload.from must be a non-empty string");
+	if (typeof to !== "string" || to.trim().length === 0) return fail("copy: payload.to must be a non-empty string");
+	try {
+		const fromTarget = await ctx.fs.resolve(from, { signal });
+		const fromOs = ctx.fs.processPath(fromTarget);
+		const info = await ctx.fs.stat(fromTarget, signal);
+		if (info === void 0) return fail(`path not found: ${from}`);
+		const toTarget = await ctx.fs.resolve(to, { signal });
+		const toOs = ctx.fs.processPath(toTarget);
+		if (fromOs.toLowerCase() === toOs.toLowerCase()) return fail("copy: source and destination are the same path");
+		if (info.type === "directory") {
+			const sep = fromOs.includes("\\") ? "\\" : "/";
+			const prefix = fromOs.endsWith("\\") || fromOs.endsWith("/") ? fromOs : fromOs + sep;
+			if (toOs.toLowerCase().startsWith(prefix.toLowerCase())) return fail("copy: cannot copy a folder into itself");
+		}
+		await cp(fromOs, toOs, {
+			recursive: true,
+			force: overwrite,
+			errorOnExist: !overwrite
+		});
+		return {
+			ok: true,
+			value: { path: toOs }
+		};
+	} catch (error) {
+		if (isFsErrorCode(error, "ERR_FS_CP_EEXIST")) return {
+			ok: false,
+			error: {
+				code: "exists",
+				message: "destination already exists",
+				details: {}
+			}
+		};
+		return fail(mapError(error));
+	}
+}
+/** Spawn one short-lived desktop command; resolves once the process launched. */
+function runDesktop(command, args) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			detached: true,
+			stdio: "ignore",
+			windowsHide: true
+		});
+		child.once("error", reject);
+		child.once("spawn", () => {
+			child.unref();
+			resolve();
+		});
+	});
+}
+/** Run one command and capture its stdout; rejects on non-zero exit. */
+function execCapture(command, args) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, args, { windowsHide: true });
+		let out = "";
+		child.stdout.on("data", (chunk) => {
+			out += chunk.toString();
+		});
+		child.once("error", reject);
+		child.once("close", (code) => {
+			if (code === 0) resolve(out);
+			else reject(/* @__PURE__ */ new Error(`${command} exited with code ${code}`));
+		});
+	});
+}
+/** Reveal one resolved OS path in the platform's file manager. */
+async function revealNative(osPath, isDir, signal) {
+	signal.throwIfAborted();
+	const platform = process.platform;
+	if (platform === "win32") {
+		await runDesktop("explorer.exe", isDir ? [osPath] : ["/select,", osPath]);
+		return;
+	}
+	if (platform === "darwin") {
+		await runDesktop("open", isDir ? [osPath] : ["-R", osPath]);
+		return;
+	}
+	if (platform === "linux") {
+		const env = process.env;
+		if (env.WSL_DISTRO_NAME !== void 0 || env.WSL_INTEROP !== void 0) {
+			const windowsPath = (await execCapture("wslpath", ["-w", osPath])).replace(/[\r\n]+$/, "");
+			if (windowsPath === "") throw new Error("wslpath returned no Windows path");
+			await runDesktop("explorer.exe", isDir ? [windowsPath] : ["/select,", windowsPath]);
+			return;
+		}
+		await runDesktop("xdg-open", [isDir ? osPath : dirname(osPath)]);
+		return;
+	}
+	throw new Error(`reveal in the file manager is unsupported on ${platform}`);
+}
+/** RPC endpoint: reveal one explorer path in the OS file manager. */
+async function revealInExplorer(ctx, payload, signal) {
+	const path = pathOf(payload);
+	const kind = typeof payload === "object" && payload !== null ? payload.kind : void 0;
+	if (path === void 0) return fail("reveal: payload.path must be a non-empty string");
+	try {
+		const target = await ctx.fs.resolve(path, { signal });
+		const info = await ctx.fs.stat(target, signal);
+		if (info === void 0) return fail(`path not found: ${path}`);
+		const isDir = kind === "dir" || info.type === "directory";
+		const osPath = ctx.fs.processPath(target);
+		await revealNative(osPath, isDir, signal);
+		return {
+			ok: true,
+			value: { path: osPath }
+		};
+	} catch (error) {
+		if (signal.aborted) return fail("reveal: aborted");
+		return fail(mapError(error));
+	}
+}
 //#endregion
-export { CHANNEL, MAX_PREVIEW_BYTES, apply, inject, kindOf, mapDirEntry, mapError, name, sortEntries };
+export { CHANNEL, EVENTS_PREFIX, MAX_IMAGE_BYTES, MAX_PREVIEW_BYTES, RAW_PREFIX, apply, imageMimeOf, inject, isImagePath, kindOf, mapDirEntry, mapError, name, sortEntries };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-plugin-workbench",
   "description": "VS Code-style workspace file explorer + editable preview for the dsh web GUI",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "type": "module",
   "packageManager": "pnpm@11.21.0",
   "engines": {
@@ -57,6 +57,7 @@
     "@types/react": "~18.3.1",
     "highlight.js": "^11.11.1",
     "lightningcss": "^1.32.0",
+    "markdown-it": "^15.0.0",
     "react": "^18.2.0",
     "tsdown": "0.22.14",
     "typescript": "^5.6.0"