@xopcai/xopc 0.0.84 → 0.0.85

package/dist/src/share/share-store.js

@@ -1,14 +1,14 @@
+import { resolveStateDir } from "../config/paths-state.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { resolveStateDir } from "../config/paths-state.js";
 import { init_paths } from "../config/paths.js";
+import { SHARE_CONFIG_DEFAULTS } from "./share-types.js";
 import { isPathUnderWorkspace } from "../gateway/workspace-editor-path.js";
 import { logShareAudit } from "./share-audit.js";
-import { SHARE_CONFIG_DEFAULTS } from "./share-types.js";
-import { randomBytes, randomUUID } from "node:crypto";
+import { join, relative, resolve } from "node:path";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { lstat, realpath, stat } from "node:fs/promises";
-import { join } from "node:path";
+import { randomBytes, randomUUID } from "node:crypto";
+import { lstat, readdir, realpath, stat } from "node:fs/promises";
 //#region src/share/share-store.ts
 init_paths();
 init_logger();
@@ -18,17 +18,20 @@ const CLEANUP_INTERVAL_MS = 10 * 6e4;
 const EXPIRED_RETENTION_MS = 1440 * 6e4;
 const MAX_STORED_RECORDS = 500;
 const TRUNCATE_TO = 200;
-const VIEW_COUNT_DEBOUNCE_MS = 2e3;
+const COUNTER_DEBOUNCE_MS = 2e3;
 function resolveSharesPath() {
 	return join(resolveStateDir(), SHARES_FILE);
 }
 var ShareStore = class {
 	shares = /* @__PURE__ */ new Map();
 	tokenIndex = /* @__PURE__ */ new Map();
-	viewCountDirty = false;
-	viewCountTimer = null;
+	dirty = false;
+	debounceTimer = null;
 	cleanupTimer = null;
 	config;
+	listingCache = /* @__PURE__ */ new Map();
+	/** Optional cleanup hook invoked when a share record is dropped (e.g. delete thumbnail). */
+	onCleanup = null;
 	constructor(config) {
 		this.config = {
 			...SHARE_CONFIG_DEFAULTS,
@@ -43,6 +46,10 @@ var ShareStore = class {
 			...config
 		};
 	}
+	/** Register a cleanup hook (idempotent — last wins). */
+	setCleanupHook(hook) {
+		this.onCleanup = hook;
+	}
 	getConfig() {
 		return { ...this.config };
 	}
@@ -57,6 +64,30 @@ var ShareStore = class {
 		}
 		const absolutePath = await this.resolveAndValidatePath(relPath, workspaceRoot);
 		const fileStat = await stat(absolutePath);
+		const detectedKind = fileStat.isDirectory() ? "directory" : "file";
+		const requestedKind = params.kind ?? detectedKind;
+		if (requestedKind !== detectedKind) throw new Error(`Requested share kind '${requestedKind}' does not match filesystem (got '${detectedKind}')`);
+		if (requestedKind === "file") return this.createFileShare({
+			params,
+			absolutePath,
+			fileStat,
+			relPath,
+			workspaceRoot,
+			ttlMs,
+			gatewayTokenHash
+		});
+		return this.createDirectoryShare({
+			params,
+			absolutePath,
+			fileStat,
+			relPath,
+			workspaceRoot,
+			ttlMs,
+			gatewayTokenHash
+		});
+	}
+	async createFileShare(args) {
+		const { params, absolutePath, fileStat, relPath, workspaceRoot, ttlMs, gatewayTokenHash } = args;
 		if (!fileStat.isFile()) throw new Error("Path is not a regular file");
 		if (fileStat.size > this.config.maxFileSize) {
 			const maxMb = (this.config.maxFileSize / 1048576).toFixed(0);
@@ -65,42 +96,108 @@ var ShareStore = class {
 		if ((await lstat(absolutePath)).isSymbolicLink()) {
 			if (!isPathUnderWorkspace(workspaceRoot, await realpath(absolutePath))) throw new Error("Symlink target is outside workspace");
 		}
-		const id = randomUUID();
-		const token = randomBytes(32).toString("base64url");
-		const fileName = relPath.split("/").pop() ?? relPath;
+		const fileName = relPath.split("/").pop() || relPath;
 		const mimeType = resolveMimeType(fileName);
-		const now = /* @__PURE__ */ new Date();
-		const record = {
-			id,
-			token,
+		const record = this.buildRecord({
+			kind: "file",
 			absolutePath,
-			workspaceRelativePath: relPath,
 			workspaceRoot,
+			workspaceRelativePath: relPath,
 			inode: fileStat.ino,
-			isDirectory: false,
 			fileName,
 			fileSize: fileStat.size,
 			mimeType,
+			ttlMs,
+			maxViews: params.maxViews,
+			description: params.description,
+			gatewayTokenHash
+		});
+		this.persistAndAudit(record, "share.create", `Share created: ${record.fileName}`, {
+			fileName: record.fileName,
+			fileSize: record.fileSize,
+			ttlMs
+		});
+		return record;
+	}
+	async createDirectoryShare(args) {
+		const { params, absolutePath, fileStat, relPath, workspaceRoot, ttlMs, gatewayTokenHash } = args;
+		const dirCfg = this.config.directory;
+		if (!dirCfg.enabled) throw new Error("Directory sharing is disabled");
+		const followSymlinks = params.followSymlinks ?? false;
+		const maxDepth = params.maxDepth ?? dirCfg.maxDepth;
+		const summary = await scanDirectory(absolutePath, {
+			workspaceRoot,
+			followSymlinks,
+			maxDepth,
+			maxFileCount: Math.min(params.maxFileCount ?? dirCfg.maxFileCount, dirCfg.maxFileCount),
+			maxFolderSize: Math.min(params.maxFolderSize ?? dirCfg.maxFolderSize, dirCfg.maxFolderSize)
+		});
+		const fileName = relPath.split("/").pop() || relPath || "shared";
+		const record = this.buildRecord({
+			kind: "directory",
+			absolutePath,
+			workspaceRoot,
+			workspaceRelativePath: relPath,
+			inode: fileStat.ino,
+			fileName,
+			fileSize: summary.totalSize,
+			mimeType: "application/x-directory",
+			ttlMs,
+			maxViews: params.maxViews,
+			description: params.description,
+			gatewayTokenHash,
+			directory: {
+				mode: params.directoryMode ?? "browse",
+				entryCount: summary.entryCount,
+				followSymlinks,
+				maxDepth
+			}
+		});
+		this.persistAndAudit(record, "share.create", `Folder share created: ${record.fileName}`, {
+			fileName: record.fileName,
+			entryCount: summary.entryCount,
+			totalSize: summary.totalSize,
+			ttlMs,
+			mode: record.directory?.mode
+		});
+		return record;
+	}
+	buildRecord(input) {
+		const id = randomUUID();
+		const token = randomBytes(32).toString("base64url");
+		const now = /* @__PURE__ */ new Date();
+		const record = {
+			id,
+			token,
+			absolutePath: input.absolutePath,
+			workspaceRelativePath: input.workspaceRelativePath,
+			workspaceRoot: input.workspaceRoot,
+			inode: input.inode,
+			kind: input.kind,
+			fileName: input.fileName,
+			fileSize: input.fileSize,
+			mimeType: input.mimeType,
 			createdAt: now.toISOString(),
-			expiresAt: new Date(now.getTime() + ttlMs).toISOString(),
-			maxViews: params.maxViews ?? null,
-			viewCount: 0,
+			expiresAt: new Date(now.getTime() + input.ttlMs).toISOString(),
+			maxViews: input.maxViews ?? null,
+			downloadCount: 0,
 			revoked: false,
-			createdByTokenHash: gatewayTokenHash,
-			description: params.description
+			createdByTokenHash: input.gatewayTokenHash,
+			description: input.description,
+			directory: input.directory
 		};
 		this.shares.set(id, record);
 		this.tokenIndex.set(token, id);
-		this.persistSync();
-		logShareAudit("share.create", {
-			shareId: id,
-			tokenPrefix: token.slice(0, 8),
-			fileName,
-			fileSize: fileStat.size,
-			ttlMs
-		}, `Share created: ${fileName}`);
 		return record;
 	}
+	persistAndAudit(record, event, message, extra) {
+		this.persistSync();
+		logShareAudit(event, {
+			shareId: record.id,
+			tokenPrefix: record.token.slice(0, 8),
+			...extra
+		}, message);
+	}
 	getById(id) {
 		return this.shares.get(id) ?? null;
 	}
@@ -119,17 +216,17 @@ var ShareStore = class {
 			valid: false,
 			reason: "expired"
 		};
-		if (record.maxViews !== null && record.viewCount >= record.maxViews) return {
+		if (record.maxViews !== null && record.downloadCount >= record.maxViews) return {
 			valid: false,
 			reason: "max_views"
 		};
 		return { valid: true };
 	}
-	/** Increment view count (debounced persist). */
-	incrementViewCount(id) {
+	/** Increment download counter (used by directory & file downloads). Debounced persist. */
+	incrementDownloadCount(id) {
 		const record = this.shares.get(id);
 		if (!record) return;
-		record.viewCount++;
+		record.downloadCount++;
 		this.scheduleDebouncedPersist();
 	}
 	/** Check if the file still exists and inode matches. */
@@ -147,7 +244,7 @@ var ShareStore = class {
 					tokenPrefix: record.token.slice(0, 8),
 					oldInode: record.inode,
 					newInode: fileStat.ino
-				}, `Share file replaced (inode changed): ${record.fileName}`);
+				}, `Share path replaced (inode changed): ${record.fileName}`);
 				return {
 					valid: false,
 					reason: "file_deleted"
@@ -161,10 +258,125 @@ var ShareStore = class {
 			};
 		}
 	}
+	/**
+	* Resolve a child path inside a directory share. Returns the absolute path
+	* if it stays within both the share root and the workspace.
+	*/
+	async resolveDirectoryChild(record, relativePath) {
+		if (record.kind !== "directory") return {
+			ok: false,
+			reason: "not_directory"
+		};
+		const trimmed = (relativePath ?? "").replace(/^\/+/, "").replace(/\\/g, "/");
+		if (trimmed.includes("..") || trimmed.includes("\0")) return {
+			ok: false,
+			reason: "path_traversal"
+		};
+		const abs = resolve(record.absolutePath, trimmed);
+		const relToShare = relative(record.absolutePath, abs);
+		if (relToShare.startsWith("..") || relToShare.split(/[/\\]/).includes("..")) return {
+			ok: false,
+			reason: "path_outside_share"
+		};
+		try {
+			const real = await realpath(abs);
+			if (!isPathUnderWorkspace(record.workspaceRoot, real)) return {
+				ok: false,
+				reason: "path_outside_workspace"
+			};
+			const relToShareReal = relative(record.absolutePath, real);
+			if (relToShareReal.startsWith("..") || relToShareReal.split(/[/\\]/).includes("..")) return {
+				ok: false,
+				reason: "path_outside_share"
+			};
+			return {
+				ok: true,
+				absolutePath: real
+			};
+		} catch {
+			return {
+				ok: false,
+				reason: "not_found"
+			};
+		}
+	}
+	/** List a single directory level (cached, share-root-relative). */
+	async listDirectory(record, relativePath) {
+		if (record.kind !== "directory") throw new Error("Not a directory share");
+		const trimmed = (relativePath ?? "").replace(/^\/+/, "");
+		const cacheKey = `${record.id}::${trimmed}`;
+		const cacheTtl = this.config.directory.listingCacheMs;
+		const now = Date.now();
+		const cached = this.listingCache.get(cacheKey);
+		if (cached && cached.expiresAt > now) return cached.listing;
+		const resolved = await this.resolveDirectoryChild(record, trimmed);
+		if (resolved.ok !== true) throw new Error(resolved.reason);
+		const absDir = resolved.absolutePath;
+		if (!(await stat(absDir)).isDirectory()) throw new Error("not_directory");
+		const followSymlinks = record.directory?.followSymlinks ?? false;
+		const dirents = await readdir(absDir, { withFileTypes: true });
+		const entries = [];
+		let truncated = false;
+		const limit = 2e3;
+		for (const dirent of dirents) {
+			if (entries.length >= limit) {
+				truncated = true;
+				break;
+			}
+			const childAbs = resolve(absDir, dirent.name);
+			try {
+				const childLstat = await lstat(childAbs);
+				if (childLstat.isSymbolicLink()) {
+					if (!followSymlinks) continue;
+					const real = await realpath(childAbs);
+					if (!isPathUnderWorkspace(record.workspaceRoot, real)) continue;
+					if (relative(record.absolutePath, real).startsWith("..")) continue;
+				}
+				const childStat = childLstat.isSymbolicLink() ? await stat(childAbs) : childLstat;
+				const childRel = trimmed ? `${trimmed}/${dirent.name}` : dirent.name;
+				entries.push({
+					name: dirent.name,
+					path: childRel,
+					isDirectory: childStat.isDirectory(),
+					size: childStat.isFile() ? childStat.size : 0,
+					mtime: childStat.mtime.toISOString(),
+					mimeType: childStat.isDirectory() ? "application/x-directory" : resolveMimeType(dirent.name)
+				});
+			} catch {}
+		}
+		entries.sort((a, b) => {
+			if (a.isDirectory !== b.isDirectory) return a.isDirectory ? -1 : 1;
+			return a.name.localeCompare(b.name);
+		});
+		const listing = {
+			path: trimmed,
+			entries,
+			truncated
+		};
+		if (cacheTtl > 0) this.listingCache.set(cacheKey, {
+			listing,
+			expiresAt: now + cacheTtl
+		});
+		return listing;
+	}
+	/** Update thumbnail status. Persists immediately so generator restart is safe. */
+	setThumbnailStatus(id, status) {
+		const record = this.shares.get(id);
+		if (!record) return;
+		record.thumbnailStatus = status;
+		if (status === "ready") record.thumbnailGeneratedAt = (/* @__PURE__ */ new Date()).toISOString();
+		if (status === "failed") record.thumbnailFailedAt = (/* @__PURE__ */ new Date()).toISOString();
+		this.persistSync();
+	}
+	/** Drop the listing cache for a share (used on revoke/update). */
+	invalidateListingCache(shareId) {
+		for (const key of this.listingCache.keys()) if (key.startsWith(`${shareId}::`)) this.listingCache.delete(key);
+	}
 	revoke(id) {
 		const record = this.shares.get(id);
 		if (!record) return false;
 		record.revoked = true;
+		this.invalidateListingCache(id);
 		this.persistSync();
 		logShareAudit("share.revoke", {
 			shareId: id,
@@ -179,6 +391,7 @@ var ShareStore = class {
 			const record = this.shares.get(id);
 			if (record && !record.revoked) {
 				record.revoked = true;
+				this.invalidateListingCache(id);
 				count++;
 				logShareAudit("share.revoke", {
 					shareId: id,
@@ -195,6 +408,7 @@ var ShareStore = class {
 		let count = 0;
 		for (const record of this.shares.values()) if (!record.revoked && now >= new Date(record.expiresAt).getTime()) {
 			record.revoked = true;
+			this.invalidateListingCache(record.id);
 			count++;
 		}
 		if (count > 0) this.persistSync();
@@ -265,16 +479,16 @@ var ShareStore = class {
 		}, null, 2)}\n`, "utf8");
 	}
 	scheduleDebouncedPersist() {
-		this.viewCountDirty = true;
-		if (this.viewCountTimer) return;
-		this.viewCountTimer = setTimeout(() => {
-			this.viewCountTimer = null;
-			if (this.viewCountDirty) {
-				this.viewCountDirty = false;
+		this.dirty = true;
+		if (this.debounceTimer) return;
+		this.debounceTimer = setTimeout(() => {
+			this.debounceTimer = null;
+			if (this.dirty) {
+				this.dirty = false;
 				this.persistSync();
 			}
-		}, VIEW_COUNT_DEBOUNCE_MS);
-		this.viewCountTimer.unref?.();
+		}, COUNTER_DEBOUNCE_MS);
+		this.debounceTimer.unref?.();
 	}
 	startCleanupTimer() {
 		this.cleanupTimer = setInterval(() => {
@@ -288,6 +502,15 @@ var ShareStore = class {
 		for (const [id, record] of this.shares) if (now - new Date(record.expiresAt).getTime() > EXPIRED_RETENTION_MS) {
 			this.shares.delete(id);
 			this.tokenIndex.delete(record.token);
+			this.invalidateListingCache(id);
+			if (this.onCleanup) try {
+				this.onCleanup(record);
+			} catch (err) {
+				log.warn({
+					err,
+					shareId: id
+				}, "Share cleanup hook threw");
+			}
 			removed++;
 		}
 		if (removed > 0) {
@@ -300,28 +523,63 @@ var ShareStore = class {
 			clearInterval(this.cleanupTimer);
 			this.cleanupTimer = null;
 		}
-		if (this.viewCountTimer) {
-			clearTimeout(this.viewCountTimer);
-			this.viewCountTimer = null;
+		if (this.debounceTimer) {
+			clearTimeout(this.debounceTimer);
+			this.debounceTimer = null;
 		}
-		if (this.viewCountDirty) {
-			this.viewCountDirty = false;
+		if (this.dirty) {
+			this.dirty = false;
 			this.persistSync();
 		}
+		this.listingCache.clear();
 	}
 	async resolveAndValidatePath(relPath, workspaceRoot) {
 		const trimmed = relPath.trim().replace(/\\/g, "/").replace(/^\/+/, "");
 		if (!trimmed) throw new Error("Empty path");
 		if (trimmed.includes("..")) throw new Error("Path traversal not allowed");
 		if (trimmed.includes("\0")) throw new Error("Invalid path");
-		const { resolve } = await import("node:path");
-		const { relative } = await import("node:path");
 		const abs = resolve(workspaceRoot, trimmed);
 		const relToRoot = relative(resolve(workspaceRoot), abs);
 		if (relToRoot.startsWith("..") || relToRoot.split(/[/\\]/).includes("..")) throw new Error("Path is outside workspace");
 		return abs;
 	}
 };
+async function scanDirectory(root, opts) {
+	let entryCount = 0;
+	let totalSize = 0;
+	async function walk(dir, depth) {
+		if (depth > opts.maxDepth) return;
+		const dirents = await readdir(dir, { withFileTypes: true });
+		for (const dirent of dirents) {
+			if (entryCount >= opts.maxFileCount) throw new Error(`Folder exceeds maxFileCount (${opts.maxFileCount})`);
+			const childAbs = resolve(dir, dirent.name);
+			const childLstat = await lstat(childAbs);
+			let effectiveStat = childLstat;
+			if (childLstat.isSymbolicLink()) {
+				if (!opts.followSymlinks) continue;
+				const real = await realpath(childAbs);
+				if (!isPathUnderWorkspace(opts.workspaceRoot, real)) throw new Error("Symlink target escapes workspace");
+				effectiveStat = await stat(childAbs);
+			}
+			if (effectiveStat.isFile()) {
+				entryCount++;
+				totalSize += effectiveStat.size;
+				if (totalSize > opts.maxFolderSize) {
+					const maxMb = (opts.maxFolderSize / 1048576).toFixed(0);
+					throw new Error(`Folder exceeds maxFolderSize (${maxMb} MB)`);
+				}
+			} else if (effectiveStat.isDirectory()) {
+				entryCount++;
+				await walk(childAbs, depth + 1);
+			}
+		}
+	}
+	await walk(root, 0);
+	return {
+		entryCount,
+		totalSize
+	};
+}
 const MIME_BY_EXT = {
 	png: "image/png",
 	jpg: "image/jpeg",
@@ -337,6 +595,7 @@ const MIME_BY_EXT = {
 	html: "text/html",
 	css: "text/css",
 	js: "text/javascript",
+	mjs: "text/javascript",
 	ts: "text/typescript",
 	xml: "application/xml",
 	csv: "text/csv",
@@ -349,6 +608,12 @@ const MIME_BY_EXT = {
 	mp4: "video/mp4",
 	webm: "video/webm",
 	mov: "video/quicktime",
+	wasm: "application/wasm",
+	woff: "font/woff",
+	woff2: "font/woff2",
+	ttf: "font/ttf",
+	otf: "font/otf",
+	ico: "image/x-icon",
 	docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
 	xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
 	pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
@@ -356,6 +621,12 @@ const MIME_BY_EXT = {
 function resolveMimeType(fileName) {
 	return MIME_BY_EXT[fileName.split(".").pop()?.toLowerCase() ?? ""] || "application/octet-stream";
 }
+/** HTTP Content-Type with charset for text-like bodies (browser inline preview). */
+function shareResponseContentType(mime) {
+	if (/;\s*charset=/i.test(mime)) return mime;
+	if (mime.startsWith("text/") || mime === "application/json" || mime === "application/javascript" || mime === "application/xml" || mime === "image/svg+xml") return `${mime}; charset=utf-8`;
+	return mime;
+}
 let singleton = null;
 function getShareStore(config) {
 	if (!singleton) singleton = new ShareStore(config);
@@ -366,6 +637,6 @@ function resetShareStoreForTests() {
 	singleton = null;
 }
 //#endregion
-export { ShareStore, getShareStore, resetShareStoreForTests };
+export { ShareStore, getShareStore, resetShareStoreForTests, resolveMimeType, shareResponseContentType };
 
 //# sourceMappingURL=share-store.js.map