@fps-games/editor 0.2.1-beta.2 → 0.2.1-beta.4

package/node_modules/@fps-games/editor-playable-sdk/dist/vite/editor-service-vite.js

@@ -0,0 +1,592 @@
+import { randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
+import { readFileSync, unlinkSync } from 'node:fs';
+import { chmod, mkdir, open, readFile, realpath, rename, unlink, } from 'node:fs/promises';
+import path from 'node:path';
+import { createEditorServiceGateway, } from '@fps-games/editor-core';
+import { EDITOR_SERVICE_DESCRIPTOR_SCHEMA_VERSION, EDITOR_SERVICE_GATEWAY_PATH, EDITOR_SERVICE_PROTOCOL_VERSION, } from '@fps-games/editor-protocol';
+import { createFpsGameEditorProjectServiceAuthority } from './project-editor-service.js';
+export const PLAYABLE_EDITOR_AGENT_RUNTIME_RELATIVE_PATH = path.join('node_modules', '.fps-editor', 'agent-runtime.json');
+const ACTIVE_PROJECT_SERVICE_ROOTS = new Map();
+const PROCESS_TERMINATION_SIGNALS = ['SIGHUP', 'SIGINT', 'SIGTERM'];
+const PROCESS_OWNED_FILE_CLEANUPS = new Set();
+const PROCESS_SIGNAL_HANDLERS = new Map();
+let processExitCleanupInstalled = false;
+export async function installPlayableEditorViteEditorService(input) {
+    if (input.options?.enabled === false)
+        return null;
+    const canonicalProjectRoot = await realpath(input.integration.projectRoot);
+    const descriptorPath = path.resolve(canonicalProjectRoot, PLAYABLE_EDITOR_AGENT_RUNTIME_RELATIVE_PATH);
+    assertDescriptorInsideProject(canonicalProjectRoot, descriptorPath);
+    const serviceInstanceId = input.credentials?.serviceInstanceId ?? randomUUID();
+    const token = input.credentials?.token ?? randomBytes(32).toString('base64url');
+    const tokenScopes = normalizeTokenScopes(input.options?.tokenScopes);
+    const startedAt = new Date().toISOString();
+    const activeOwner = ACTIVE_PROJECT_SERVICE_ROOTS.get(canonicalProjectRoot);
+    if (activeOwner)
+        throw new Error(`A live Editor Service already owns this project: ${activeOwner}.`);
+    ACTIVE_PROJECT_SERVICE_ROOTS.set(canonicalProjectRoot, serviceInstanceId);
+    let projectRootClaimed = true;
+    const releaseProcessProjectRoot = () => {
+        if (!projectRootClaimed)
+            return;
+        projectRootClaimed = false;
+        if (ACTIVE_PROJECT_SERVICE_ROOTS.get(canonicalProjectRoot) === serviceInstanceId) {
+            ACTIVE_PROJECT_SERVICE_ROOTS.delete(canonicalProjectRoot);
+        }
+    };
+    const descriptorDirectory = path.dirname(descriptorPath);
+    let projectLeaseOwner;
+    const projectLeasePath = `${descriptorPath}.owner`;
+    try {
+        await mkdir(descriptorDirectory, { recursive: true, mode: 0o700 });
+        await chmod(descriptorDirectory, 0o700);
+        assertDescriptorInsideProject(canonicalProjectRoot, await realpath(descriptorDirectory));
+        projectLeaseOwner = await claimDescriptorLock(projectLeasePath);
+    }
+    catch (error) {
+        releaseProcessProjectRoot();
+        throw error;
+    }
+    let projectLeaseClaimed = true;
+    const cleanupOwnedFilesAtProcessExit = () => {
+        removeOwnedRuntimeDescriptorSync(descriptorPath, {
+            canonicalProjectRoot,
+            serviceInstanceId,
+            pid: process.pid,
+            token,
+        });
+        removeOwnedDescriptorLockSync(projectLeasePath, projectLeaseOwner);
+    };
+    const releaseProcessExitCleanup = registerProcessOwnedFileCleanup(cleanupOwnedFilesAtProcessExit);
+    const releaseProjectRoot = async () => {
+        if (!projectLeaseClaimed)
+            return;
+        projectLeaseClaimed = false;
+        try {
+            await removeOwnedDescriptorLock(projectLeasePath, projectLeaseOwner);
+        }
+        finally {
+            releaseProcessProjectRoot();
+            releaseProcessExitCleanup();
+        }
+    };
+    let authority;
+    try {
+        authority = await createFpsGameEditorProjectServiceAuthority({
+            projectRoot: canonicalProjectRoot,
+            project: input.options?.project,
+            serviceInstanceId,
+            server: input.server,
+        });
+    }
+    catch (error) {
+        await releaseProjectRoot();
+        throw error;
+    }
+    let gateway;
+    let releaseBrowserCommandForwarder;
+    try {
+        gateway = createEditorServiceGateway({
+            canonicalProjectRoot,
+            packageVersion: input.integration.buildInfo.version,
+            buildKey: input.integration.buildInfo.cacheKey,
+            startedAt,
+            host: authority.host,
+            readTraces: authority.readTraces,
+            readDocumentExport: authority.readDocumentExport,
+        });
+        releaseBrowserCommandForwarder = authority.bindBrowserCommandForwarder(gateway.forwardBrowserCommand);
+    }
+    catch (error) {
+        await authority.dispose().catch(() => undefined);
+        await releaseProjectRoot();
+        throw error;
+    }
+    const gatewayPath = EDITOR_SERVICE_GATEWAY_PATH;
+    let descriptor = null;
+    let descriptorPublication = null;
+    let disposal = null;
+    let disposed = false;
+    const gatewayMiddleware = async (request, response, next) => {
+        const requestUrl = new URL(request.url ?? '', 'http://fps-editor.local');
+        if (requestUrl.pathname !== gatewayPath)
+            return next();
+        setGatewayHeaders(request, response);
+        if (request.method === 'OPTIONS') {
+            response.statusCode = 204;
+            response.end();
+            return;
+        }
+        if (request.method !== 'POST') {
+            sendJson(response, 405, { ok: false, diagnostics: [{ severity: 'error', source: 'transport', code: 'http.methodNotAllowed', message: 'Editor Service Gateway requires POST.' }] });
+            return;
+        }
+        if (!hasBearerToken(request.headers?.authorization, token)) {
+            sendJson(response, 401, { ok: false, diagnostics: [{ severity: 'error', source: 'transport', code: 'auth.invalidToken', message: 'Editor Service bearer token is invalid.' }] });
+            return;
+        }
+        try {
+            const gatewayRequest = await readJsonBody(request);
+            const result = await gateway.handle(gatewayRequest, tokenScopes);
+            sendJson(response, result.ok ? 200 : 400, result);
+        }
+        catch (error) {
+            sendJson(response, 400, {
+                ok: false,
+                diagnostics: [{
+                        severity: 'error',
+                        source: 'transport',
+                        code: 'request.invalidJson',
+                        message: error instanceof Error ? error.message : String(error),
+                    }],
+            });
+        }
+    };
+    try {
+        input.server.middlewares.use(gatewayMiddleware);
+        const middlewareStack = input.server.middlewares.stack;
+        const ownMiddlewareIndex = middlewareStack?.findIndex(layer => layer.handle === gatewayMiddleware) ?? -1;
+        const fallbackIndex = middlewareStack?.findIndex(layer => /vite(?:SpaFallback|IndexHtml|404)Middleware/.test(layer.handle?.name ?? '')) ?? -1;
+        if (middlewareStack && ownMiddlewareIndex >= 0 && fallbackIndex >= 0 && ownMiddlewareIndex > fallbackIndex) {
+            const [layer] = middlewareStack.splice(ownMiddlewareIndex, 1);
+            middlewareStack.splice(fallbackIndex, 0, layer);
+        }
+    }
+    catch (error) {
+        releaseBrowserCommandForwarder();
+        gateway.dispose();
+        await authority.dispose().catch(() => undefined);
+        await releaseProjectRoot();
+        throw error;
+    }
+    const publishDescriptor = () => {
+        if (disposed || descriptor)
+            return Promise.resolve();
+        if (descriptorPublication)
+            return descriptorPublication;
+        const publication = (async () => {
+            const endpoint = resolveServerEndpoint(input.server, gatewayPath);
+            const candidate = {
+                schemaVersion: EDITOR_SERVICE_DESCRIPTOR_SCHEMA_VERSION,
+                protocolVersion: EDITOR_SERVICE_PROTOCOL_VERSION,
+                canonicalProjectRoot,
+                serviceInstanceId,
+                pid: process.pid,
+                endpoint,
+                startedAt,
+                packageName: '@fps-games/editor',
+                packageVersion: input.integration.buildInfo.version,
+                buildKey: input.integration.buildInfo.cacheKey,
+                token,
+                tokenScopes,
+            };
+            await claimRuntimeDescriptor(descriptorPath, candidate);
+            descriptor = candidate;
+            if (disposed) {
+                await removeOwnedDescriptor(descriptorPath, candidate);
+                descriptor = null;
+                return;
+            }
+            input.logger?.info?.(`[fps-editor] Project Editor Service ready at ${endpoint}`);
+        })();
+        const trackedPublication = publication.finally(() => {
+            if (descriptorPublication === trackedPublication)
+                descriptorPublication = null;
+        });
+        descriptorPublication = trackedPublication;
+        return trackedPublication;
+    };
+    const onListening = () => {
+        void publishDescriptor().catch((error) => {
+            input.logger?.error?.(`[fps-editor] Failed to publish Agent runtime descriptor: ${formatError(error)}`);
+            void dispose();
+        });
+    };
+    const onClose = () => { void dispose(); };
+    input.server.httpServer?.once('close', onClose);
+    if (input.server.httpServer?.listening) {
+        try {
+            await publishDescriptor();
+        }
+        catch (error) {
+            await dispose().catch(() => undefined);
+            throw error;
+        }
+    }
+    else
+        input.server.httpServer?.once('listening', onListening);
+    async function dispose() {
+        if (disposal)
+            return disposal;
+        disposed = true;
+        disposal = (async () => {
+            input.server.httpServer?.off('listening', onListening);
+            input.server.httpServer?.off('close', onClose);
+            const activeMiddlewareStack = input.server.middlewares.stack;
+            const middlewareIndex = activeMiddlewareStack?.findIndex(layer => layer.handle === gatewayMiddleware) ?? -1;
+            if (middlewareIndex >= 0)
+                activeMiddlewareStack.splice(middlewareIndex, 1);
+            const errors = [];
+            try {
+                releaseBrowserCommandForwarder();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+            gateway.dispose();
+            try {
+                await descriptorPublication;
+            }
+            catch (error) {
+                errors.push(error);
+            }
+            try {
+                if (descriptor)
+                    await removeOwnedDescriptor(descriptorPath, descriptor);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+            try {
+                await authority.dispose();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+            finally {
+                try {
+                    await releaseProjectRoot();
+                }
+                catch (error) {
+                    errors.push(error);
+                }
+            }
+            if (errors.length) {
+                const error = new Error('Editor Service disposal failed.');
+                error.errors = errors;
+                throw error;
+            }
+        })();
+        return disposal;
+    }
+    return Object.freeze({ descriptorPath, serviceInstanceId, dispose });
+}
+async function claimRuntimeDescriptor(descriptorPath, descriptor) {
+    const directory = path.dirname(descriptorPath);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    assertDescriptorInsideProject(descriptor.canonicalProjectRoot, await realpath(directory));
+    const lockPath = `${descriptorPath}.lock`;
+    const lockOwner = await claimDescriptorLock(lockPath);
+    try {
+        await assertOwnedDescriptorLock(lockPath, lockOwner);
+        await assertDescriptorAvailable(descriptorPath, descriptor.canonicalProjectRoot);
+        const temporaryPath = `${descriptorPath}.${process.pid}.${randomUUID()}.tmp`;
+        let committed = false;
+        try {
+            const handle = await open(temporaryPath, 'wx', 0o600);
+            try {
+                await handle.writeFile(`${JSON.stringify(descriptor, null, 2)}\n`, 'utf8');
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            await chmod(temporaryPath, 0o600);
+            await assertOwnedDescriptorLock(lockPath, lockOwner);
+            await rename(temporaryPath, descriptorPath);
+            committed = true;
+        }
+        finally {
+            if (!committed)
+                await unlink(temporaryPath).catch(() => undefined);
+        }
+    }
+    finally {
+        await removeOwnedDescriptorLock(lockPath, lockOwner);
+    }
+}
+function registerProcessOwnedFileCleanup(cleanup) {
+    PROCESS_OWNED_FILE_CLEANUPS.add(cleanup);
+    installProcessOwnedFileCleanupHooks();
+    let registered = true;
+    return () => {
+        if (!registered)
+            return;
+        registered = false;
+        PROCESS_OWNED_FILE_CLEANUPS.delete(cleanup);
+        if (PROCESS_OWNED_FILE_CLEANUPS.size === 0)
+            removeProcessOwnedFileCleanupHooks();
+    };
+}
+function installProcessOwnedFileCleanupHooks() {
+    if (processExitCleanupInstalled)
+        return;
+    processExitCleanupInstalled = true;
+    process.once('exit', cleanupProcessOwnedFiles);
+    for (const signal of PROCESS_TERMINATION_SIGNALS) {
+        const handler = () => {
+            cleanupProcessOwnedFiles();
+            removeProcessOwnedFileCleanupHooks();
+            queueMicrotask(() => {
+                try {
+                    process.kill(process.pid, signal);
+                }
+                catch {
+                    // The process may already be exiting through another signal handler.
+                }
+            });
+        };
+        PROCESS_SIGNAL_HANDLERS.set(signal, handler);
+        process.once(signal, handler);
+    }
+}
+function removeProcessOwnedFileCleanupHooks() {
+    if (!processExitCleanupInstalled)
+        return;
+    processExitCleanupInstalled = false;
+    process.off('exit', cleanupProcessOwnedFiles);
+    for (const [signal, handler] of PROCESS_SIGNAL_HANDLERS) {
+        process.off(signal, handler);
+    }
+    PROCESS_SIGNAL_HANDLERS.clear();
+}
+function cleanupProcessOwnedFiles() {
+    for (const cleanup of PROCESS_OWNED_FILE_CLEANUPS)
+        cleanup();
+}
+function removeOwnedRuntimeDescriptorSync(descriptorPath, owner) {
+    try {
+        const current = JSON.parse(readFileSync(descriptorPath, 'utf8'));
+        if (current.canonicalProjectRoot !== owner.canonicalProjectRoot
+            || current.serviceInstanceId !== owner.serviceInstanceId
+            || current.pid !== owner.pid
+            || current.token !== owner.token)
+            return;
+        unlinkSync(descriptorPath);
+    }
+    catch {
+        // Process exit cleanup is best effort. Stale-owner recovery remains authoritative.
+    }
+}
+function removeOwnedDescriptorLockSync(lockPath, owner) {
+    try {
+        const current = parseDescriptorLockOwner(readFileSync(lockPath, 'utf8'));
+        if (!current || current.pid !== owner.pid || current.token !== owner.token)
+            return;
+        unlinkSync(lockPath);
+    }
+    catch {
+        // Process exit cleanup is best effort. Stale-owner recovery remains authoritative.
+    }
+}
+async function claimDescriptorLock(lockPath) {
+    const owner = { pid: process.pid, token: randomUUID() };
+    const serialized = `${JSON.stringify(owner)}\n`;
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+        try {
+            const handle = await open(lockPath, 'wx', 0o600);
+            try {
+                await handle.writeFile(serialized, 'utf8');
+                await handle.chmod(0o600);
+            }
+            finally {
+                await handle.close();
+            }
+            return owner;
+        }
+        catch (error) {
+            if (error?.code !== 'EEXIST')
+                throw error;
+        }
+        const observed = await readFile(lockPath, 'utf8').catch(() => null);
+        if (observed === null)
+            continue;
+        const existing = parseDescriptorLockOwner(observed);
+        if (!existing || isProcessAlive(existing.pid)) {
+            throw new Error(`Editor Service descriptor lock has an ambiguous live owner at ${lockPath}.`);
+        }
+        const quarantine = `${lockPath}.stale.${process.pid}.${randomUUID()}`;
+        try {
+            await rename(lockPath, quarantine);
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT')
+                continue;
+            throw error;
+        }
+        const moved = await readFile(quarantine, 'utf8').catch(() => null);
+        if (moved !== observed) {
+            await rename(quarantine, lockPath).catch(() => undefined);
+            throw new Error(`Editor Service descriptor lock changed during stale-owner recovery at ${lockPath}.`);
+        }
+        await unlink(quarantine).catch(() => undefined);
+    }
+    throw new Error(`Editor Service descriptor lock could not be claimed at ${lockPath}.`);
+}
+function parseDescriptorLockOwner(source) {
+    try {
+        const value = JSON.parse(source);
+        return Number.isSafeInteger(value?.pid) && value.pid > 0 && typeof value.token === 'string' && value.token
+            ? value
+            : null;
+    }
+    catch {
+        const legacyPid = Number(source.trim());
+        return Number.isSafeInteger(legacyPid) && legacyPid > 0
+            ? { pid: legacyPid, token: `legacy:${legacyPid}` }
+            : null;
+    }
+}
+async function assertOwnedDescriptorLock(lockPath, owner) {
+    const current = parseDescriptorLockOwner(await readFile(lockPath, 'utf8').catch(() => ''));
+    if (!current || current.pid !== owner.pid || current.token !== owner.token) {
+        throw new Error(`Editor Service descriptor lock ownership was lost at ${lockPath}.`);
+    }
+}
+async function removeOwnedDescriptorLock(lockPath, owner) {
+    const current = parseDescriptorLockOwner(await readFile(lockPath, 'utf8').catch(() => ''));
+    if (current?.pid === owner.pid && current.token === owner.token) {
+        await unlink(lockPath).catch(() => undefined);
+    }
+}
+async function assertDescriptorAvailable(descriptorPath, canonicalProjectRoot) {
+    const existing = await readDescriptor(descriptorPath);
+    if (!existing)
+        return;
+    if (existing.canonicalProjectRoot !== canonicalProjectRoot) {
+        throw new Error(`Editor Service descriptor project identity mismatch at ${descriptorPath}.`);
+    }
+    if (await isDescriptorHealthy(existing)) {
+        throw new Error(`A live Editor Service already owns this project: ${existing.serviceInstanceId}.`);
+    }
+    if (isProcessAlive(existing.pid)) {
+        throw new Error(`A live Editor Service owner is temporarily unreachable; refusing to replace ${existing.serviceInstanceId}.`);
+    }
+    await unlink(descriptorPath).catch((error) => {
+        if (error?.code !== 'ENOENT')
+            throw error;
+    });
+}
+async function readDescriptor(descriptorPath) {
+    try {
+        const value = JSON.parse(await readFile(descriptorPath, 'utf8'));
+        if (!value || typeof value !== 'object' || typeof value.serviceInstanceId !== 'string'
+            || typeof value.canonicalProjectRoot !== 'string' || typeof value.endpoint !== 'string'
+            || typeof value.token !== 'string' || !Number.isSafeInteger(value.pid)) {
+            throw new Error(`Editor Service runtime descriptor is malformed at ${descriptorPath}.`);
+        }
+        return value;
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+async function isDescriptorHealthy(descriptor) {
+    if (!isProcessAlive(descriptor.pid))
+        return false;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 750);
+    try {
+        const response = await fetch(descriptor.endpoint, {
+            method: 'POST',
+            headers: { authorization: `Bearer ${descriptor.token}`, 'content-type': 'application/json' },
+            body: JSON.stringify({ kind: 'status' }),
+            signal: controller.signal,
+        });
+        if (!response.ok)
+            return false;
+        const body = await response.json();
+        return body?.ok === true
+            && body?.kind === 'status'
+            && body?.status?.serviceInstanceId === descriptor.serviceInstanceId
+            && body?.status?.canonicalProjectRoot === descriptor.canonicalProjectRoot
+            && body?.status?.protocolVersion === descriptor.protocolVersion;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error?.code === 'EPERM';
+    }
+}
+async function removeOwnedDescriptor(descriptorPath, owner) {
+    const current = await readDescriptor(descriptorPath);
+    if (!current || current.serviceInstanceId !== owner.serviceInstanceId || current.token !== owner.token)
+        return;
+    await unlink(descriptorPath).catch((error) => {
+        if (error?.code !== 'ENOENT')
+            throw error;
+    });
+}
+function resolveServerEndpoint(server, gatewayPath) {
+    const address = server.httpServer?.address();
+    if (!address || typeof address === 'string')
+        throw new Error('Vite HTTP server address is unavailable.');
+    return `http://127.0.0.1:${address.port}${gatewayPath}`;
+}
+function normalizeTokenScopes(value) {
+    const defaults = ['read', 'write'];
+    const scopes = [...new Set(value ?? defaults)];
+    if (scopes.length === 0 || scopes.some(scope => scope !== 'read' && scope !== 'write')) {
+        throw new Error('Editor Service token scopes must contain read or write.');
+    }
+    return Object.freeze(scopes);
+}
+function assertDescriptorInsideProject(projectRoot, descriptorPath) {
+    const relative = path.relative(projectRoot, descriptorPath);
+    if (!relative || relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        throw new Error('Editor Service runtime descriptor must be inside the canonical project root.');
+    }
+}
+function hasBearerToken(header, expected) {
+    if (typeof header !== 'string' || !header.startsWith('Bearer '))
+        return false;
+    const received = Buffer.from(header.slice('Bearer '.length), 'utf8');
+    const target = Buffer.from(expected, 'utf8');
+    return received.length === target.length && timingSafeEqual(received, target);
+}
+async function readJsonBody(request) {
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bytes += buffer.byteLength;
+        if (bytes > 1024 * 1024)
+            throw new Error('Editor Service request body exceeds 1 MiB.');
+        chunks.push(buffer);
+    }
+    if (chunks.length === 0)
+        throw new Error('Editor Service request body is required.');
+    return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+}
+function setGatewayHeaders(request, response) {
+    response.setHeader('Cache-Control', 'no-store');
+    response.setHeader('Content-Type', 'application/json; charset=utf-8');
+    response.setHeader('X-Content-Type-Options', 'nosniff');
+    response.setHeader('Access-Control-Allow-Headers', 'authorization, content-type');
+    response.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
+    const origin = typeof request.headers?.origin === 'string' ? request.headers.origin : undefined;
+    if (origin) {
+        response.setHeader('Access-Control-Allow-Origin', origin);
+        response.setHeader('Vary', 'Origin');
+    }
+}
+function sendJson(response, statusCode, value) {
+    response.statusCode = statusCode;
+    response.end(`${JSON.stringify(value)}\n`);
+}
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=editor-service-vite.js.map