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

package/dist/runtime/server/devmode/state-inspector.service.d.ts

@@ -0,0 +1,57 @@
+import { type DIRegistration, type HandlerInfo, IDevModeInspector } from './contracts/IDevModeInspector';
+import { RuntimeSnapshot } from './types';
+/**
+ * Implementation of the DevMode state inspector.
+ *
+ * Provides runtime introspection capabilities for debugging
+ * and monitoring during development.
+ */
+export declare class StateInspectorService extends IDevModeInspector {
+    private commandHandlers;
+    private netEventHandlers;
+    private exportHandlers;
+    private fiveMEventHandlers;
+    private get players();
+    captureSnapshot(): RuntimeSnapshot;
+    getRegisteredHandlers(): Map<string, HandlerInfo[]>;
+    getDIGraph(): DIRegistration[];
+    getPlayerStates(): Map<number, string[]>;
+    getHandlerInfo(type: string, name: string): HandlerInfo | null;
+    /**
+     * Registers a command handler for tracking.
+     */
+    registerCommandHandler(name: string, info: HandlerInfo): void;
+    /**
+     * Registers a net event handler for tracking.
+     */
+    registerNetEventHandler(name: string, info: HandlerInfo): void;
+    /**
+     * Registers an export handler for tracking.
+     */
+    registerExportHandler(name: string, info: HandlerInfo): void;
+    /**
+     * Registers a FiveM event handler for tracking.
+     */
+    registerFiveMEventHandler(name: string, info: HandlerInfo): void;
+    /**
+     * Gets all commands with their metadata.
+     */
+    getAllCommands(): Array<{
+        name: string;
+        info: HandlerInfo;
+    }>;
+    /**
+     * Gets detailed player information for debugging.
+     */
+    getPlayerDetails(clientId: number): Record<string, unknown> | null;
+    /**
+     * Gets a summary of the current runtime state.
+     */
+    getSummary(): {
+        mode: string;
+        playerCount: number;
+        handlerCounts: Record<string, number>;
+        uptime: number;
+    };
+    private getDIContainerInfo;
+}

package/dist/runtime/server/devmode/state-inspector.service.js

@@ -0,0 +1,183 @@
+"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.StateInspectorService = void 0;
+const tsyringe_1 = require("tsyringe");
+const container_1 = require("../../../kernel/di/container");
+const runtime_1 = require("../runtime");
+const player_directory_port_1 = require("../services/ports/player-directory.port");
+const IDevModeInspector_1 = require("./contracts/IDevModeInspector");
+/**
+ * Implementation of the DevMode state inspector.
+ *
+ * Provides runtime introspection capabilities for debugging
+ * and monitoring during development.
+ */
+let StateInspectorService = class StateInspectorService extends IDevModeInspector_1.IDevModeInspector {
+    constructor() {
+        super(...arguments);
+        this.commandHandlers = new Map();
+        this.netEventHandlers = new Map();
+        this.exportHandlers = new Map();
+        this.fiveMEventHandlers = new Map();
+    }
+    get players() {
+        return container_1.di.resolve(player_directory_port_1.PlayerDirectoryPort);
+    }
+    captureSnapshot() {
+        const ctx = (0, runtime_1.getRuntimeContext)();
+        const allPlayers = this.players.getAll();
+        return {
+            timestamp: Date.now(),
+            mode: ctx.mode,
+            features: Object.fromEntries(Object.entries(ctx.features).map(([key, value]) => [key, value.enabled])),
+            players: {
+                count: allPlayers.length,
+                ids: allPlayers.map((p) => p.clientID),
+            },
+            handlers: {
+                commands: Array.from(this.commandHandlers.keys()),
+                netEvents: Array.from(this.netEventHandlers.keys()),
+                exports: Array.from(this.exportHandlers.keys()),
+                fiveMEvents: Array.from(this.fiveMEventHandlers.keys()),
+            },
+            diContainer: this.getDIContainerInfo(),
+        };
+    }
+    getRegisteredHandlers() {
+        const result = new Map();
+        result.set('commands', Array.from(this.commandHandlers.values()));
+        result.set('netEvents', Array.from(this.netEventHandlers.values()));
+        result.set('exports', Array.from(this.exportHandlers.values()));
+        result.set('fiveMEvents', Array.from(this.fiveMEventHandlers.values()));
+        return result;
+    }
+    getDIGraph() {
+        var _a, _b, _c, _d;
+        const registrations = [];
+        // Get registrations from the DI container
+        // Note: This is a simplified implementation
+        // The actual implementation depends on tsyringe internals
+        try {
+            const container = container_1.di;
+            if (container._registry) {
+                for (const [token, registration] of container._registry) {
+                    const tokenName = typeof token === 'function' ? token.name : String(token);
+                    registrations.push({
+                        token: tokenName,
+                        implementation: (_c = (_b = (_a = registration === null || registration === void 0 ? void 0 : registration.provider) === null || _a === void 0 ? void 0 : _a.useClass) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : 'unknown',
+                        lifecycle: ((_d = registration === null || registration === void 0 ? void 0 : registration.options) === null || _d === void 0 ? void 0 : _d.lifecycle) === 0 ? 'transient' : 'singleton',
+                    });
+                }
+            }
+        }
+        catch (_e) {
+            // Fallback if we can't access internals
+        }
+        return registrations;
+    }
+    getPlayerStates() {
+        const states = new Map();
+        const allPlayers = this.players.getAll();
+        for (const player of allPlayers) {
+            states.set(player.clientID, player.getStates());
+        }
+        return states;
+    }
+    getHandlerInfo(type, name) {
+        var _a, _b, _c, _d;
+        switch (type) {
+            case 'command':
+                return (_a = this.commandHandlers.get(name)) !== null && _a !== void 0 ? _a : null;
+            case 'netEvent':
+                return (_b = this.netEventHandlers.get(name)) !== null && _b !== void 0 ? _b : null;
+            case 'export':
+                return (_c = this.exportHandlers.get(name)) !== null && _c !== void 0 ? _c : null;
+            case 'fiveMEvent':
+                return (_d = this.fiveMEventHandlers.get(name)) !== null && _d !== void 0 ? _d : null;
+            default:
+                return null;
+        }
+    }
+    /**
+     * Registers a command handler for tracking.
+     */
+    registerCommandHandler(name, info) {
+        this.commandHandlers.set(name, info);
+    }
+    /**
+     * Registers a net event handler for tracking.
+     */
+    registerNetEventHandler(name, info) {
+        this.netEventHandlers.set(name, info);
+    }
+    /**
+     * Registers an export handler for tracking.
+     */
+    registerExportHandler(name, info) {
+        this.exportHandlers.set(name, info);
+    }
+    /**
+     * Registers a FiveM event handler for tracking.
+     */
+    registerFiveMEventHandler(name, info) {
+        this.fiveMEventHandlers.set(name, info);
+    }
+    /**
+     * Gets all commands with their metadata.
+     */
+    getAllCommands() {
+        return Array.from(this.commandHandlers.entries()).map(([name, info]) => ({
+            name,
+            info,
+        }));
+    }
+    /**
+     * Gets detailed player information for debugging.
+     */
+    getPlayerDetails(clientId) {
+        const player = this.players.getByClient(clientId);
+        if (!player)
+            return null;
+        return {
+            clientId: player.clientID,
+            accountId: player.accountID,
+            name: player.name,
+            states: player.getStates(),
+            position: player.getPosition(),
+        };
+    }
+    /**
+     * Gets a summary of the current runtime state.
+     */
+    getSummary() {
+        const ctx = (0, runtime_1.getRuntimeContext)();
+        return {
+            mode: ctx.mode,
+            playerCount: this.players.getAll().length,
+            handlerCounts: {
+                commands: this.commandHandlers.size,
+                netEvents: this.netEventHandlers.size,
+                exports: this.exportHandlers.size,
+                fiveMEvents: this.fiveMEventHandlers.size,
+            },
+            uptime: process.uptime ? process.uptime() * 1000 : 0,
+        };
+    }
+    getDIContainerInfo() {
+        const registrations = this.getDIGraph();
+        return {
+            registrations: registrations.length,
+            singletons: registrations.filter((r) => r.lifecycle === 'singleton').map((r) => r.token),
+        };
+    }
+};
+exports.StateInspectorService = StateInspectorService;
+exports.StateInspectorService = StateInspectorService = __decorate([
+    (0, tsyringe_1.injectable)()
+], StateInspectorService);

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

@@ -0,0 +1,161 @@
+import { FrameworkMode } from '../runtime';
+/**
+ * Event captured by the DevMode interceptor.
+ */
+export interface DevEvent {
+    /** Unique event identifier */
+    id: string;
+    /** Unix timestamp in milliseconds */
+    timestamp: number;
+    /** Type of event */
+    type: 'net' | 'command' | 'export' | 'fivem' | 'internal';
+    /** Event name */
+    name: string;
+    /** Direction of the event */
+    direction: 'in' | 'out';
+    /** Event arguments */
+    args: unknown[];
+    /** Result of the event (if completed) */
+    result?: unknown;
+    /** Error message (if failed) */
+    error?: string;
+    /** Execution duration in milliseconds */
+    duration?: number;
+    /** Source information */
+    source?: {
+        clientId?: number;
+        resource?: string;
+    };
+}
+/**
+ * Message sent through the DevMode bridge.
+ */
+export interface BridgeMessage {
+    type: 'log' | 'event' | 'state' | 'command' | 'reload' | 'ping' | 'pong';
+    payload: unknown;
+}
+/**
+ * Snapshot of the runtime state.
+ */
+export interface RuntimeSnapshot {
+    /** Capture timestamp */
+    timestamp: number;
+    /** Current framework mode */
+    mode: FrameworkMode;
+    /** Enabled features */
+    features: Record<string, boolean>;
+    /** Player information */
+    players: {
+        count: number;
+        ids: number[];
+    };
+    /** Registered handlers */
+    handlers: {
+        commands: string[];
+        netEvents: string[];
+        exports: string[];
+        fiveMEvents: string[];
+    };
+    /** DI container info */
+    diContainer: {
+        registrations: number;
+        singletons: string[];
+    };
+}
+/**
+ * Hot reload configuration.
+ */
+export interface HotReloadOptions {
+    /** Enable hot reload server */
+    enabled: boolean;
+    /** HTTP port for reload endpoint */
+    port: number;
+    /** Resources allowed to trigger reload (empty = all) */
+    allowedResources?: string[];
+}
+/**
+ * Bridge configuration for CLI connection.
+ */
+export interface BridgeOptions {
+    /** WebSocket URL to connect to */
+    url: string;
+    /** Auto-connect on dev mode start */
+    autoConnect: boolean;
+    /** Reconnect on disconnect */
+    reconnect?: boolean;
+    /** Reconnect interval in milliseconds */
+    reconnectInterval?: number;
+}
+/**
+ * Event interceptor configuration.
+ */
+export interface InterceptorOptions {
+    /** Enable event interception */
+    enabled: boolean;
+    /** Record event history */
+    recordHistory: boolean;
+    /** Maximum events to keep in history */
+    maxHistorySize: number;
+}
+/**
+ * Player simulator configuration.
+ */
+export interface SimulatorOptions {
+    /** Enable player simulation */
+    enabled: boolean;
+    /** Number of players to auto-connect on start */
+    autoConnectPlayers: number;
+}
+/**
+ * Main DevMode configuration.
+ */
+export interface DevModeOptions {
+    /** Enable dev mode */
+    enabled: boolean;
+    /** Hot reload configuration */
+    hotReload?: HotReloadOptions;
+    /** Bridge configuration */
+    bridge?: BridgeOptions;
+    /** Interceptor configuration */
+    interceptor?: InterceptorOptions;
+    /** Simulator configuration */
+    simulator?: SimulatorOptions;
+}
+/**
+ * Simulated player configuration.
+ */
+export interface SimulatedPlayerOptions {
+    /** Client ID (auto-generated if not provided) */
+    clientId?: number;
+    /** Account ID */
+    accountId?: string;
+    /** Player name */
+    name?: string;
+    /** Player rank */
+    rank?: number;
+    /** Player permissions */
+    permissions?: string[];
+    /** Initial states */
+    states?: string[];
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Simulated player instance.
+ */
+export interface SimulatedPlayer {
+    /** Client ID */
+    clientId: number;
+    /** Whether the player is connected */
+    connected: boolean;
+    /** Simulated network latency in ms */
+    networkLatency: number;
+    /** Emit a net event as this player */
+    emit(eventName: string, ...args: unknown[]): void;
+    /** Disconnect this player */
+    disconnect(): void;
+}
+/**
+ * Default DevMode configuration.
+ */
+export declare const DEFAULT_DEVMODE_OPTIONS: DevModeOptions;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DEVMODE_OPTIONS = void 0;
+/**
+ * Default DevMode configuration.
+ */
+exports.DEFAULT_DEVMODE_OPTIONS = {
+    enabled: false,
+    hotReload: {
+        enabled: true,
+        port: 3847,
+    },
+    bridge: {
+        url: 'ws://localhost:3848',
+        autoConnect: false,
+        reconnect: true,
+        reconnectInterval: 5000,
+    },
+    interceptor: {
+        enabled: true,
+        recordHistory: true,
+        maxHistorySize: 1000,
+    },
+    simulator: {
+        enabled: true,
+        autoConnectPlayers: 0,
+    },
+};

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

@@ -0,0 +1,2 @@
+export * from './player';
+export * from './vehicle';

package/dist/{server → runtime/server}/entities/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./player"), exports);
+__exportStar(require("./vehicle"), exports);

package/dist/{server → runtime/server}/entities/player.d.ts

@@ -1,5 +1,21 @@
-import type { Vector3 } from '../../utils';
-import type { LinkedID, PlayerSession } from '../services/player.service';
+import { IPlayerInfo } from '../../../adapters';
+import { IEntityServer } from '../../../adapters/contracts/IEntityServer';
+import { INetTransport } from '../../../adapters/contracts/INetTransport';
+import { IPlayerServer } from '../../../adapters/contracts/IPlayerServer';
+import { Vector3 } from '../../../kernel/utils';
+import { LinkedID } from '../services/types/linked-id';
+import { PlayerSession } from '../services/types/player-session.object';
+import { SerializedPlayerData } from '../types/core-exports';
+/**
+ * Adapter bundle for player operations.
+ * Passed to Player instances by PlayerDirectory.
+ */
+export interface PlayerAdapters {
+    playerInfo: IPlayerInfo;
+    playerServer: IPlayerServer;
+    entityServer: IEntityServer;
+    netTransport: INetTransport;
+}
 /**
  * Core-level representation of a connected player on the server.
  *
@@ -12,14 +28,17 @@ import type { LinkedID, PlayerSession } from '../services/player.service';
  */
 export declare class Player {
     private readonly session;
+    private readonly adapters;
     private states;
+    private position;
     /**
      * Creates a new Player entity instance.
      * This is typically instantiated by the `PlayerService` upon connection.
      *
      * @param session - The internal session data structure holding ID and metadata.
+     * @param adapters - Platform adapters for player operations.
      */
-    constructor(session: PlayerSession);
+    constructor(session: PlayerSession, adapters: PlayerAdapters);
     /**
      * The numeric FiveM Server ID (Source) of the player.
      * Useful for internal logic and array indexing.
@@ -39,6 +58,7 @@ export declare class Player {
      * The display name of the player (Steam name or FiveM username).
      */
     get name(): string;
+    getPosition(): Vector3 | undefined;
     /**
      * Retrieves all platform identifiers associated with the player (steam, license, discord, ip, etc.).
      *
@@ -53,6 +73,8 @@ export declare class Player {
      * @param args - Data to send to the client.
      */
     emit(eventName: string, ...args: any[]): void;
+    /** used to send a private message to the player */
+    send(message: string, type?: 'chat' | 'error' | 'success' | 'warning'): void;
     /**
      * Teleports the player to a given position using Server-Side natives.
      *
@@ -71,6 +93,7 @@ export declare class Player {
      * @param vector - The target coordinates (x, y, z).
      */
     teleportClient(vector: Vector3): void;
+    spawn(vector: Vector3, model?: string): void;
     /**
      * Disconnects the player from the server.
      *
@@ -154,4 +177,48 @@ export declare class Player {
      * @returns An array containing all active state keys.
      */
     getStates(): string[];
+    /**
+     * Gets the current health of the player's ped.
+     *
+     * @returns Current health value (0-200, where 100 is dead).
+     */
+    getHealth(): number;
+    /**
+     * Sets the health of the player's ped.
+     *
+     * @param health - Health value to set (0-200).
+     */
+    setHealth(health: number): void;
+    /**
+     * Gets the current armor of the player's ped.
+     *
+     * @returns Current armor value (0-100).
+     */
+    getArmor(): number;
+    /**
+     * Sets the armor of the player's ped.
+     *
+     * @param armor - Armor value to set (0-100).
+     */
+    setArmor(armor: number): void;
+    /**
+     * Kills the player by setting health to 0.
+     */
+    kill(): void;
+    /**
+     * Checks if the player is alive.
+     *
+     * @returns `true` if health is above 100 (dead threshold), `false` otherwise.
+     */
+    isAlive(): boolean;
+    /**
+     * Serializes the player data for cross-resource transfer.
+     *
+     * @remarks
+     * Creates a plain object representation of the player session that can be
+     * safely transferred between resources via FiveM exports.
+     *
+     * @returns Serialized player data DTO
+     */
+    serialize(): SerializedPlayerData;
 }