@openfairygui/backend 0.3.0 → 0.3.1

package/dist/index.mjs

@@ -41,6 +41,16 @@ function createRuntimePathPolicy() {
 		workspaceBoundary: "project-root-only"
 	};
 }
+async function assertProjectPathContained(fileSystem, projectRoot, targetPath) {
+	const [resolvedRoot, resolvedTarget] = await Promise.all([fileSystem.resolvePath(projectRoot), fileSystem.resolvePath(targetPath)]);
+	const root = normalizeComparablePath(resolvedRoot);
+	const target = normalizeComparablePath(resolvedTarget);
+	if (root === "." && !target.startsWith("/") && !/^[a-z]:\//i.test(target)) return;
+	if (target === root || target.startsWith(`${root}/`)) return;
+	const error = /* @__PURE__ */ new Error(`Project path escapes the opened root: ${targetPath}`);
+	error.code = "EACCES";
+	throw error;
+}
 async function resolveFairyPath(fileSystem, input) {
 	const resolvedInput = fileSystem.resolve(input);
 	const stat = await fileSystem.stat(resolvedInput);
@@ -121,10 +131,14 @@ function failure(stage, startedAt, error, session, options) {
 }
 //#endregion
 //#region src/services/session-project-writer.ts
-function createWriterFileSystem(fileSystem, writtenPaths, failedPaths) {
+function createWriterFileSystem(fileSystem, projectRoot, writtenPaths, failedPaths) {
+	const contained = async (targetPath, operation) => {
+		await assertProjectPathContained(fileSystem, projectRoot, targetPath);
+		return operation();
+	};
 	async function trackWrite(targetPath, write) {
 		try {
-			const result = await write();
+			const result = await contained(targetPath, write);
 			writtenPaths.push(targetPath);
 			return result;
 		} catch (error) {
@@ -133,8 +147,8 @@ function createWriterFileSystem(fileSystem, writtenPaths, failedPaths) {
 		}
 	}
 	return {
-		readFile: (path) => fileSystem.readFile(path),
-		readFileRaw: (path) => fileSystem.readFileRaw(path),
+		readFile: (path) => contained(path, () => fileSystem.readFile(path)),
+		readFileRaw: (path) => contained(path, () => fileSystem.readFileRaw(path)),
 		writeFile: (path, content) => trackWrite(path, async () => {
 			await fileSystem.mkdir(fileSystem.dirname(path), { recursive: true });
 			await fileSystem.writeFile(path, content);
@@ -143,9 +157,10 @@ function createWriterFileSystem(fileSystem, writtenPaths, failedPaths) {
 			await fileSystem.mkdir(fileSystem.dirname(path), { recursive: true });
 			await fileSystem.writeFileRaw(path, data);
 		}),
-		mkdir: (path) => fileSystem.mkdir(path, { recursive: true }),
-		readdir: (path) => fileSystem.readdir(path),
+		mkdir: (path) => contained(path, () => fileSystem.mkdir(path, { recursive: true })),
+		readdir: (path) => contained(path, () => fileSystem.readdir(path)),
 		async exists(path) {
+			await assertProjectPathContained(fileSystem, projectRoot, path);
 			try {
 				await fileSystem.stat(path);
 				return true;
@@ -160,11 +175,21 @@ function createWriterFileSystem(fileSystem, writtenPaths, failedPaths) {
 	};
 }
 async function writeSessionProject(input) {
-	await new ProjectWriter(createWriterFileSystem(input.fileSystem, input.writtenPaths, input.failedPaths)).write(input.document, input.fairyPath, {
-		staleSourceFiles: input.staleSourceFiles,
-		staleResourceFolders: input.staleResourceFolders,
-		staleBranchDirectories: input.staleBranchDirectories
-	});
+	const projectRoot = input.fileSystem.dirname(input.fairyPath);
+	const write = async (fileSystem) => {
+		await new ProjectWriter(createWriterFileSystem(fileSystem, projectRoot, input.writtenPaths, input.failedPaths)).write(input.document, input.fairyPath, {
+			staleSourceFiles: input.staleSourceFiles,
+			staleResourceFolders: input.staleResourceFolders,
+			staleBranchDirectories: input.staleBranchDirectories
+		});
+	};
+	if (!input.fileSystem.runProjectWriteTransaction) return write(input.fileSystem);
+	try {
+		await input.fileSystem.runProjectWriteTransaction(projectRoot, write);
+	} catch (error) {
+		input.writtenPaths.length = 0;
+		throw error;
+	}
 }
 //#endregion
 //#region src/services/session-utils.ts
@@ -478,7 +503,7 @@ var AuthoringService = class {
 				lastSavedRevision: session.lastSavedRevision,
 				committedPaths,
 				failedPaths,
-				diskMayBePartiallyUpdated: true
+				diskMayBePartiallyUpdated: !fileSystem.runProjectWriteTransaction
 			}, toSessionSnapshot(session, this.context.capabilities), {
 				sessionId: session.sessionId,
 				revision: session.revision
@@ -653,7 +678,7 @@ var AuthoringService = class {
 				failedPaths,
 				skippedPaths,
 				diagnostics: diagnosticsFromError,
-				diskMayBePartiallyUpdated: true
+				diskMayBePartiallyUpdated: !fileSystem.runProjectWriteTransaction
 			}, toSessionSnapshot(session, this.context.capabilities), {
 				sessionId: session.sessionId,
 				revision: session.revision,
@@ -1142,7 +1167,7 @@ var ReadService = class {
 //#endregion
 //#region src/services/runtime-service.ts
 function randomId() {
-	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+	return crypto.randomUUID();
 }
 function createCapabilityUnavailableError(capability) {
 	const artifactCapability = capability === "artifact.publish" || capability === "artifact.restore";
@@ -1155,29 +1180,33 @@ function createCapabilityUnavailableError(capability) {
 		bridgeBoundary: artifactCapability ? "external-bridge" : void 0
 	};
 }
-function createProjectReaderFileSystem(fileSystem) {
+function createProjectReaderFileSystem(fileSystem, projectRoot) {
+	const contained = async (filePath, operation) => {
+		await assertProjectPathContained(fileSystem, projectRoot, filePath);
+		return operation();
+	};
 	return {
 		readFile(filePath) {
-			return fileSystem.readFile(filePath);
+			return contained(filePath, () => fileSystem.readFile(filePath));
 		},
 		readFileRaw(filePath) {
-			return fileSystem.readFileRaw(filePath);
+			return contained(filePath, () => fileSystem.readFileRaw(filePath));
 		},
 		writeFile(filePath, content) {
-			return fileSystem.writeFile(filePath, content);
+			return contained(filePath, () => fileSystem.writeFile(filePath, content));
 		},
 		writeFileRaw(filePath, data) {
-			return fileSystem.writeFileRaw(filePath, data);
+			return contained(filePath, () => fileSystem.writeFileRaw(filePath, data));
 		},
 		async mkdir(dirPath) {
-			await fileSystem.mkdir(dirPath, { recursive: true });
+			await contained(dirPath, () => fileSystem.mkdir(dirPath, { recursive: true }));
 		},
 		readdir(dirPath) {
-			return fileSystem.readdir(dirPath);
+			return contained(dirPath, () => fileSystem.readdir(dirPath));
 		},
 		async exists(filePath) {
 			try {
-				await fileSystem.stat(filePath);
+				await contained(filePath, () => fileSystem.stat(filePath));
 				return true;
 			} catch {
 				return false;
@@ -1271,9 +1300,25 @@ var RuntimeService = class {
 		const startedAt = Date.now();
 		if (!this.context.fileSystem) return failure("runtime", startedAt, createCapabilityUnavailableError("fileSystem"));
 		const fileSystem = this.context.fileSystem;
+		if (this.context.allowedProjectRoots?.length) {
+			let allowed = false;
+			for (const root of this.context.allowedProjectRoots) try {
+				await assertProjectPathContained(fileSystem, root, input.projectPath);
+				allowed = true;
+				break;
+			} catch (error) {
+				if (error.code !== "EACCES") throw error;
+			}
+			if (!allowed) return failure("runtime", startedAt, {
+				code: "project_root_not_allowed",
+				message: "Project path is outside the configured allowed roots.",
+				projectPath: input.projectPath
+			});
+		}
 		const { fairyPath, canonicalProjectPath, canonicalPathKey } = await resolveCanonicalProjectRoot(fileSystem, input.projectPath);
+		await fileSystem.validateProjectRoot?.(canonicalProjectPath);
 		const existingSessionId = this.context.sessionsByPath.get(canonicalPathKey);
-		const lockFilePath = fileSystem.join(canonicalProjectPath, ".openfairygui.backend.lock");
+		const lockFilePath = fileSystem.getSessionLockPath?.(canonicalProjectPath) ?? fileSystem.join(canonicalProjectPath, ".openfairygui.backend.lock");
 		if (existingSessionId) return failure("runtime", startedAt, {
 			code: "lock_conflict",
 			kind: "in_process_session_exists",
@@ -1293,7 +1338,7 @@ var RuntimeService = class {
 				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
 				canonicalPathKey
 			}));
-			const read = await new ProjectReader(createProjectReaderFileSystem(fileSystem)).readDetailed(fairyPath, { hydrateResourceBytes: true });
+			const read = await new ProjectReader(createProjectReaderFileSystem(fileSystem, canonicalProjectPath)).readDetailed(fairyPath, { hydrateResourceBytes: true });
 			if (!read.document) throw new Error(read.diagnostics[0]?.message ?? `Unable to read project: ${fairyPath}`);
 			const document = read.document;
 			const project = liftDocumentToUamProject(document);
@@ -1351,6 +1396,11 @@ var RuntimeService = class {
 	openProjectSession(input) {
 		const startedAt = Date.now();
 		const sessionId = input.sessionId ?? randomId();
+		if (this.context.sessions.has(sessionId)) return failure("runtime", startedAt, {
+			code: "session_id_conflict",
+			message: `Session id is already in use: ${sessionId}`,
+			sessionId
+		});
 		const storage = input.storage;
 		const memoryProjectPath = `memory://${sessionId}`;
 		const canonicalProjectPath = storage?.canonicalProjectPath ?? input.canonicalProjectPath ?? (storage ? storage.fileSystem.dirname(storage.fairyPath) || "." : memoryProjectPath);
@@ -1477,7 +1527,7 @@ const ARTIFACT_BRIDGE_CAPABILITY = {
 	bridgeEntrypoint: "@openfairygui/backend/node",
 	reason: "publish/restore require explicit Node-hosted filesystem and artifact execution."
 };
-function createCapabilities() {
+function createCapabilities(atomicSave = false) {
 	return {
 		contractVersion: BACKEND_CONTRACT_VERSION,
 		capabilitySchemaVersion: 3,
@@ -1549,7 +1599,7 @@ function createCapabilities() {
 			sessionRuntime: true,
 			advisoryLocking: true,
 			coordinatedSave: true,
-			atomicSave: false,
+			atomicSave,
 			staleRevisionProtection: true,
 			pathPolicy: createRuntimePathPolicy(),
 			events: {
@@ -1595,10 +1645,11 @@ var BackendRuntime = class {
 	jobService;
 	constructor(options = {}) {
 		this.fileSystem = options.fileSystem;
-		this.capabilities = createCapabilities();
+		this.capabilities = createCapabilities(Boolean(options.fileSystem?.runProjectWriteTransaction));
 		this.context = {
 			fileSystem: this.fileSystem,
 			host: options.host,
+			allowedProjectRoots: options.allowedProjectRoots,
 			capabilities: this.capabilities,
 			sessions: this.sessions,
 			sessionsByPath: this.sessionsByPath,
@@ -1621,7 +1672,16 @@ var BackendRuntime = class {
 		return this.readService.getCapabilities();
 	}
 	async openSession(input) {
-		return this.runtimeService.openSession(input);
+		const startedAt = Date.now();
+		try {
+			return await this.runtimeService.openSession(input);
+		} catch {
+			return failure("runtime", startedAt, {
+				code: "project_open_failed",
+				message: "Unable to open project.",
+				projectPath: input.projectPath
+			});
+		}
 	}
 	openProjectSession(input) {
 		return this.runtimeService.openProjectSession(input);
@@ -1645,7 +1705,7 @@ var BackendRuntime = class {
 		return this.authoringService.materializeSession(input);
 	}
 	async closeSession(input) {
-		return this.runtimeService.closeSession(input);
+		return this.authoringService.runSessionExclusive(input.sessionId, () => this.runtimeService.closeSession(input));
 	}
 	getEvents(input) {
 		return this.eventService.getEvents(input);