@open-core/framework 0.1.0-alpha.1 → 0.2.1-beta.1

package/dist/runtime/server/devmode/hot-reload.server.d.ts

@@ -0,0 +1,74 @@
+import { HotReloadOptions } from './types';
+/**
+ * Log message structure for HTTP transport.
+ */
+export interface LogMessage {
+    level: number;
+    domain: string;
+    message: string;
+    timestamp: number;
+    context?: Record<string, unknown>;
+    error?: {
+        name: string;
+        message: string;
+        stack?: string;
+    };
+}
+/**
+ * HTTP server for handling hot reload requests from the CLI.
+ *
+ * Provides an endpoint that the CLI can call to restart resources
+ * after file changes are detected.
+ *
+ * @example
+ * ```typescript
+ * const server = new HotReloadServer({ enabled: true, port: 3847 })
+ * server.start()
+ * // CLI calls POST /restart?resource=my-resource
+ * ```
+ */
+export declare class HotReloadServer {
+    private server;
+    private options;
+    private logBuffer;
+    private maxLogBuffer;
+    private logListeners;
+    constructor(options: HotReloadOptions);
+    /**
+     * Adds logs to the buffer (called by HttpLogTransport).
+     */
+    addLogs(logs: LogMessage[]): void;
+    /**
+     * Gets and clears buffered logs.
+     */
+    consumeLogs(): LogMessage[];
+    /**
+     * Adds a listener for new logs.
+     */
+    onLogs(listener: (logs: LogMessage[]) => void): () => void;
+    /**
+     * Starts the hot reload HTTP server.
+     */
+    start(): void;
+    /**
+     * Stops the hot reload server.
+     */
+    stop(): void;
+    /**
+     * Checks if the server is running.
+     */
+    isRunning(): boolean;
+    private handleRequest;
+    private handleRestart;
+    private handleRefresh;
+    private handleHealth;
+    private isResourceAllowed;
+    /**
+     * Handles GET /logs - CLI polls for buffered logs.
+     */
+    private handleGetLogs;
+    /**
+     * Handles POST /logs - Framework pushes logs to buffer.
+     */
+    private handlePostLogs;
+}

package/dist/runtime/server/devmode/hot-reload.server.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HotReloadServer = void 0;
+const logger_1 = require("../../../kernel/shared/logger");
+// Lazy-loaded http module (only loaded at runtime, not bundled)
+let httpModule = null;
+// Use variable to prevent esbuild from statically analyzing the require
+const HTTP_MODULE = 'http';
+function getHttpSync() {
+    if (!httpModule) {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        httpModule = require(HTTP_MODULE);
+    }
+    return httpModule;
+}
+// Safe wrappers for FiveM globals (no-op in Node.js)
+function safeGetCurrentResourceName() {
+    if (typeof GetCurrentResourceName === 'function') {
+        return GetCurrentResourceName();
+    }
+    return 'unknown';
+}
+function safeExecuteCommand(command) {
+    if (typeof ExecuteCommand === 'function') {
+        ExecuteCommand(command);
+    }
+    else {
+        logger_1.loggers.bootstrap.warn('[DevMode] ExecuteCommand not available (not running in FiveM)');
+    }
+}
+/**
+ * HTTP server for handling hot reload requests from the CLI.
+ *
+ * Provides an endpoint that the CLI can call to restart resources
+ * after file changes are detected.
+ *
+ * @example
+ * ```typescript
+ * const server = new HotReloadServer({ enabled: true, port: 3847 })
+ * server.start()
+ * // CLI calls POST /restart?resource=my-resource
+ * ```
+ */
+class HotReloadServer {
+    constructor(options) {
+        this.server = null;
+        this.logBuffer = [];
+        this.maxLogBuffer = 1000;
+        this.logListeners = [];
+        this.options = options;
+    }
+    /**
+     * Adds logs to the buffer (called by HttpLogTransport).
+     */
+    addLogs(logs) {
+        this.logBuffer.push(...logs);
+        if (this.logBuffer.length > this.maxLogBuffer) {
+            this.logBuffer = this.logBuffer.slice(-this.maxLogBuffer);
+        }
+        // Notify listeners
+        for (const listener of this.logListeners) {
+            listener(logs);
+        }
+    }
+    /**
+     * Gets and clears buffered logs.
+     */
+    consumeLogs() {
+        const logs = this.logBuffer;
+        this.logBuffer = [];
+        return logs;
+    }
+    /**
+     * Adds a listener for new logs.
+     */
+    onLogs(listener) {
+        this.logListeners.push(listener);
+        return () => {
+            const idx = this.logListeners.indexOf(listener);
+            if (idx !== -1)
+                this.logListeners.splice(idx, 1);
+        };
+    }
+    /**
+     * Starts the hot reload HTTP server.
+     */
+    start() {
+        if (!this.options.enabled)
+            return;
+        if (this.server)
+            return;
+        const http = getHttpSync();
+        this.server = http.createServer((req, res) => {
+            this.handleRequest(req, res);
+        });
+        this.server.listen(this.options.port, '127.0.0.1', () => {
+            logger_1.loggers.bootstrap.info(`[DevMode] Hot reload server listening on port ${this.options.port}`);
+        });
+        this.server.on('error', (error) => {
+            logger_1.loggers.bootstrap.error(`[DevMode] Hot reload server error`, {}, error);
+        });
+    }
+    /**
+     * Stops the hot reload server.
+     */
+    stop() {
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+            logger_1.loggers.bootstrap.info('[DevMode] Hot reload server stopped');
+        }
+    }
+    /**
+     * Checks if the server is running.
+     */
+    isRunning() {
+        return this.server !== null;
+    }
+    handleRequest(req, res) {
+        var _a, _b;
+        // CORS headers for CLI access
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        if (req.method === 'POST' && ((_a = req.url) === null || _a === void 0 ? void 0 : _a.startsWith('/restart'))) {
+            this.handleRestart(req, res);
+            return;
+        }
+        if (req.method === 'POST' && ((_b = req.url) === null || _b === void 0 ? void 0 : _b.startsWith('/refresh'))) {
+            this.handleRefresh(res);
+            return;
+        }
+        if (req.method === 'GET' && req.url === '/health') {
+            this.handleHealth(res);
+            return;
+        }
+        // Log endpoints for CLI polling
+        if (req.method === 'GET' && req.url === '/logs') {
+            this.handleGetLogs(res);
+            return;
+        }
+        if (req.method === 'POST' && req.url === '/logs') {
+            this.handlePostLogs(req, res);
+            return;
+        }
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Not found' }));
+    }
+    handleRestart(req, res) {
+        var _a;
+        try {
+            const url = new URL((_a = req.url) !== null && _a !== void 0 ? _a : '', `http://localhost:${this.options.port}`);
+            const resource = url.searchParams.get('resource');
+            if (!resource) {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Missing resource parameter' }));
+                return;
+            }
+            if (!this.isResourceAllowed(resource)) {
+                res.writeHead(403, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Resource not allowed for hot reload' }));
+                return;
+            }
+            // Don't restart ourselves
+            const currentResource = safeGetCurrentResourceName();
+            if (resource === currentResource) {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Cannot restart the hot-reload resource itself' }));
+                return;
+            }
+            logger_1.loggers.bootstrap.info(`[DevMode] Hot reloading resource: ${resource}`);
+            // Execute the restart command
+            safeExecuteCommand(`restart ${resource}`);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true, resource }));
+        }
+        catch (error) {
+            logger_1.loggers.bootstrap.error('[DevMode] Hot reload error', {}, error);
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Internal server error' }));
+        }
+    }
+    handleRefresh(res) {
+        try {
+            logger_1.loggers.bootstrap.info('[DevMode] Refreshing resources');
+            safeExecuteCommand('refresh');
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true }));
+        }
+        catch (error) {
+            logger_1.loggers.bootstrap.error('[DevMode] Refresh error', {}, error);
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Internal server error' }));
+        }
+    }
+    handleHealth(res) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+            status: 'ok',
+            resource: safeGetCurrentResourceName(),
+            timestamp: Date.now(),
+        }));
+    }
+    isResourceAllowed(resource) {
+        if (!this.options.allowedResources || this.options.allowedResources.length === 0) {
+            return true;
+        }
+        return this.options.allowedResources.includes(resource);
+    }
+    /**
+     * Handles GET /logs - CLI polls for buffered logs.
+     */
+    handleGetLogs(res) {
+        const logs = this.consumeLogs();
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ logs, timestamp: Date.now() }));
+    }
+    /**
+     * Handles POST /logs - Framework pushes logs to buffer.
+     */
+    handlePostLogs(req, res) {
+        let body = '';
+        req.on('data', (chunk) => {
+            body += chunk.toString();
+            // Limit body size to 1MB
+            if (body.length > 1024 * 1024) {
+                res.writeHead(413, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Payload too large' }));
+                req.destroy();
+            }
+        });
+        req.on('end', () => {
+            try {
+                const data = JSON.parse(body);
+                if (data.type === 'logs' && Array.isArray(data.payload)) {
+                    this.addLogs(data.payload);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ success: true, received: data.payload.length }));
+                }
+                else {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Invalid payload format' }));
+                }
+            }
+            catch (_a) {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Invalid JSON' }));
+            }
+        });
+        req.on('error', () => {
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Request error' }));
+        });
+    }
+}
+exports.HotReloadServer = HotReloadServer;

package/dist/runtime/server/devmode/index.d.ts

@@ -0,0 +1,8 @@
+export * from './contracts';
+export { DevModeService } from './dev-mode.service';
+export { EventInterceptorService } from './event-interceptor.service';
+export { HotReloadServer } from './hot-reload.server';
+export { PlayerSimulatorService } from './player-simulator.service';
+export { StateInspectorService } from './state-inspector.service';
+export type { BridgeMessage, BridgeOptions, DevEvent, DevModeOptions, HotReloadOptions, InterceptorOptions, RuntimeSnapshot, SimulatedPlayer, SimulatedPlayerOptions, SimulatorOptions, } from './types';
+export { DEFAULT_DEVMODE_OPTIONS } from './types';

package/dist/runtime/server/devmode/index.js

@@ -0,0 +1,32 @@
+"use strict";
+// DevMode - Development tools for OpenCore
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DEVMODE_OPTIONS = exports.StateInspectorService = exports.PlayerSimulatorService = exports.HotReloadServer = exports.EventInterceptorService = exports.DevModeService = void 0;
+// Contracts
+__exportStar(require("./contracts"), exports);
+var dev_mode_service_1 = require("./dev-mode.service");
+Object.defineProperty(exports, "DevModeService", { enumerable: true, get: function () { return dev_mode_service_1.DevModeService; } });
+var event_interceptor_service_1 = require("./event-interceptor.service");
+Object.defineProperty(exports, "EventInterceptorService", { enumerable: true, get: function () { return event_interceptor_service_1.EventInterceptorService; } });
+var hot_reload_server_1 = require("./hot-reload.server");
+Object.defineProperty(exports, "HotReloadServer", { enumerable: true, get: function () { return hot_reload_server_1.HotReloadServer; } });
+var player_simulator_service_1 = require("./player-simulator.service");
+Object.defineProperty(exports, "PlayerSimulatorService", { enumerable: true, get: function () { return player_simulator_service_1.PlayerSimulatorService; } });
+var state_inspector_service_1 = require("./state-inspector.service");
+Object.defineProperty(exports, "StateInspectorService", { enumerable: true, get: function () { return state_inspector_service_1.StateInspectorService; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "DEFAULT_DEVMODE_OPTIONS", { enumerable: true, get: function () { return types_1.DEFAULT_DEVMODE_OPTIONS; } });

package/dist/runtime/server/devmode/player-simulator.service.d.ts

@@ -0,0 +1,66 @@
+import { SimulatedPlayer, SimulatedPlayerOptions } from './types';
+/**
+ * Service for simulating player connections during development.
+ *
+ * Allows developers to test their code without needing actual FiveM clients.
+ * Simulated players can emit events and execute commands.
+ */
+export declare class PlayerSimulatorService {
+    private simulatedPlayers;
+    private clientIdCounter;
+    private get transport();
+    private get sessionLifecycle();
+    /**
+     * Connects a simulated player.
+     * @param options - Player configuration
+     * @returns Simulated player instance
+     */
+    connect(options?: Partial<SimulatedPlayerOptions>): SimulatedPlayer;
+    /**
+     * Disconnects a simulated player.
+     * @param clientId - Client ID to disconnect
+     */
+    disconnect(clientId: number): void;
+    /**
+     * Connects multiple simulated players.
+     * @param count - Number of players to connect
+     * @param baseOptions - Base options for all players
+     * @returns Array of simulated players
+     */
+    connectMany(count: number, baseOptions?: Partial<SimulatedPlayerOptions>): SimulatedPlayer[];
+    /**
+     * Disconnects all simulated players.
+     */
+    disconnectAll(): void;
+    /**
+     * Gets all simulated players.
+     */
+    getAll(): SimulatedPlayer[];
+    /**
+     * Gets a simulated player by client ID.
+     */
+    get(clientId: number): SimulatedPlayer | null;
+    /**
+     * Sets network latency for a simulated player.
+     * @param clientId - Client ID
+     * @param latency - Latency in milliseconds
+     */
+    setNetworkLatency(clientId: number, latency: number): void;
+    /**
+     * Simulates a net event from a player.
+     * @param clientId - Client ID
+     * @param eventName - Event name
+     * @param args - Event arguments
+     */
+    emitAsPlayer(clientId: number, eventName: string, ...args: unknown[]): Promise<void>;
+    /**
+     * Gets statistics about simulated players.
+     */
+    getStatistics(): {
+        total: number;
+        connected: number;
+        avgLatency: number;
+    };
+    private createSimulatedPlayerInterface;
+    private delay;
+}

package/dist/runtime/server/devmode/player-simulator.service.js

@@ -0,0 +1,202 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayerSimulatorService = void 0;
+const tsyringe_1 = require("tsyringe");
+const INetTransport_1 = require("../../../adapters/contracts/INetTransport");
+const container_1 = require("../../../kernel/di/container");
+const logger_1 = require("../../../kernel/shared/logger");
+const player_session_lifecycle_port_1 = require("../services/ports/player-session-lifecycle.port");
+/**
+ * Service for simulating player connections during development.
+ *
+ * Allows developers to test their code without needing actual FiveM clients.
+ * Simulated players can emit events and execute commands.
+ */
+let PlayerSimulatorService = class PlayerSimulatorService {
+    constructor() {
+        this.simulatedPlayers = new Map();
+        this.clientIdCounter = 90000; // Start high to avoid conflicts with real players
+    }
+    get transport() {
+        return container_1.di.resolve(INetTransport_1.INetTransport);
+    }
+    get sessionLifecycle() {
+        return container_1.di.resolve(player_session_lifecycle_port_1.PlayerSessionLifecyclePort);
+    }
+    /**
+     * Connects a simulated player.
+     * @param options - Player configuration
+     * @returns Simulated player instance
+     */
+    connect(options) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const clientId = (_a = options === null || options === void 0 ? void 0 : options.clientId) !== null && _a !== void 0 ? _a : this.clientIdCounter++;
+        const name = (_b = options === null || options === void 0 ? void 0 : options.name) !== null && _b !== void 0 ? _b : `SimPlayer_${clientId}`;
+        const accountId = (_c = options === null || options === void 0 ? void 0 : options.accountId) !== null && _c !== void 0 ? _c : `sim_account_${clientId}`;
+        // Create the simulated player data
+        const playerData = {
+            clientId,
+            name,
+            accountId,
+            rank: (_d = options === null || options === void 0 ? void 0 : options.rank) !== null && _d !== void 0 ? _d : 0,
+            permissions: (_e = options === null || options === void 0 ? void 0 : options.permissions) !== null && _e !== void 0 ? _e : [],
+            states: (_f = options === null || options === void 0 ? void 0 : options.states) !== null && _f !== void 0 ? _f : [],
+            metadata: (_g = options === null || options === void 0 ? void 0 : options.metadata) !== null && _g !== void 0 ? _g : {},
+            connected: true,
+            networkLatency: 0,
+        };
+        this.simulatedPlayers.set(clientId, playerData);
+        // Bind player session via lifecycle port
+        try {
+            this.sessionLifecycle.bind(clientId, {
+                license: `sim_${accountId}`,
+                discord: `sim_${clientId}`,
+            });
+        }
+        catch (error) {
+            logger_1.loggers.bootstrap.warn('[DevMode] Could not bind player session', {
+                clientId,
+                error: error.message,
+            });
+        }
+        logger_1.loggers.bootstrap.info(`[DevMode] Simulated player connected: ${name} (${clientId})`);
+        // Return the simulated player interface
+        return this.createSimulatedPlayerInterface(playerData);
+    }
+    /**
+     * Disconnects a simulated player.
+     * @param clientId - Client ID to disconnect
+     */
+    disconnect(clientId) {
+        const player = this.simulatedPlayers.get(clientId);
+        if (!player)
+            return;
+        player.connected = false;
+        // Unbind player session
+        try {
+            this.sessionLifecycle.unbind(clientId);
+        }
+        catch (error) {
+            logger_1.loggers.bootstrap.warn('[DevMode] Could not unbind player session', {
+                clientId,
+                error: error.message,
+            });
+        }
+        this.simulatedPlayers.delete(clientId);
+        logger_1.loggers.bootstrap.info(`[DevMode] Simulated player disconnected: ${player.name} (${clientId})`);
+    }
+    /**
+     * Connects multiple simulated players.
+     * @param count - Number of players to connect
+     * @param baseOptions - Base options for all players
+     * @returns Array of simulated players
+     */
+    connectMany(count, baseOptions) {
+        const players = [];
+        for (let i = 0; i < count; i++) {
+            players.push(this.connect(Object.assign(Object.assign({}, baseOptions), { name: (baseOptions === null || baseOptions === void 0 ? void 0 : baseOptions.name) ? `${baseOptions.name}_${i}` : undefined })));
+        }
+        return players;
+    }
+    /**
+     * Disconnects all simulated players.
+     */
+    disconnectAll() {
+        for (const clientId of this.simulatedPlayers.keys()) {
+            this.disconnect(clientId);
+        }
+    }
+    /**
+     * Gets all simulated players.
+     */
+    getAll() {
+        return Array.from(this.simulatedPlayers.values())
+            .filter((p) => p.connected)
+            .map((p) => this.createSimulatedPlayerInterface(p));
+    }
+    /**
+     * Gets a simulated player by client ID.
+     */
+    get(clientId) {
+        const player = this.simulatedPlayers.get(clientId);
+        if (!player || !player.connected)
+            return null;
+        return this.createSimulatedPlayerInterface(player);
+    }
+    /**
+     * Sets network latency for a simulated player.
+     * @param clientId - Client ID
+     * @param latency - Latency in milliseconds
+     */
+    setNetworkLatency(clientId, latency) {
+        const player = this.simulatedPlayers.get(clientId);
+        if (player) {
+            player.networkLatency = latency;
+        }
+    }
+    /**
+     * Simulates a net event from a player.
+     * @param clientId - Client ID
+     * @param eventName - Event name
+     * @param args - Event arguments
+     */
+    async emitAsPlayer(clientId, eventName, ...args) {
+        const player = this.simulatedPlayers.get(clientId);
+        if (!player || !player.connected) {
+            throw new Error(`Simulated player ${clientId} not found or disconnected`);
+        }
+        // Add artificial latency if configured
+        if (player.networkLatency > 0) {
+            await this.delay(player.networkLatency);
+        }
+        // Use the node transport to simulate the event
+        const nodeTransport = this.transport;
+        if (typeof nodeTransport.simulateClientEvent === 'function') {
+            nodeTransport.simulateClientEvent(eventName, clientId, ...args);
+        }
+        else {
+            logger_1.loggers.bootstrap.warn('[DevMode] Transport does not support event simulation');
+        }
+    }
+    /**
+     * Gets statistics about simulated players.
+     */
+    getStatistics() {
+        const players = Array.from(this.simulatedPlayers.values());
+        const connected = players.filter((p) => p.connected);
+        const avgLatency = connected.length > 0
+            ? connected.reduce((sum, p) => sum + p.networkLatency, 0) / connected.length
+            : 0;
+        return {
+            total: players.length,
+            connected: connected.length,
+            avgLatency,
+        };
+    }
+    createSimulatedPlayerInterface(data) {
+        return {
+            clientId: data.clientId,
+            connected: data.connected,
+            networkLatency: data.networkLatency,
+            emit: (eventName, ...args) => {
+                void this.emitAsPlayer(data.clientId, eventName, ...args);
+            },
+            disconnect: () => {
+                this.disconnect(data.clientId);
+            },
+        };
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+};
+exports.PlayerSimulatorService = PlayerSimulatorService;
+exports.PlayerSimulatorService = PlayerSimulatorService = __decorate([
+    (0, tsyringe_1.injectable)()
+], PlayerSimulatorService);