@open-core/framework 1.0.4-beta.1 → 1.0.5-beta.2

package/dist/runtime/server/apis/vehicle-modification.api.js

@@ -0,0 +1,313 @@
+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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'tsyringe';
+import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
+import { coreLogger } from '../../../kernel/logger';
+import { Vehicles } from './vehicles.api';
+/**
+ * Service for handling vehicle modifications with validation.
+ *
+ * This service is separated from VehicleService to maintain single responsibility.
+ * All modifications are validated server-side before being applied.
+ *
+ * Security features:
+ * - Ownership validation
+ * - Proximity checks
+ * - Modification limits
+ * - Audit logging
+ */
+let VehicleModification = class VehicleModification {
+    vehicleService;
+    events;
+    constructor(vehicleService, events) {
+        this.vehicleService = vehicleService;
+        this.events = events;
+    }
+    /**
+     * Applies modifications to a vehicle with validation.
+     *
+     * @param options - Modification options
+     * @returns Success status
+     */
+    applyModifications(options) {
+        const { networkId, mods, requestedBy } = options;
+        const vehicle = this.vehicleService.getByNetworkId(networkId);
+        if (!vehicle) {
+            coreLogger.warn('Vehicle not found for modification', { networkId });
+            return false;
+        }
+        if (!vehicle.exists) {
+            coreLogger.warn('Vehicle no longer exists', { networkId });
+            return false;
+        }
+        if (requestedBy !== undefined) {
+            if (!this.vehicleService.validateOwnership(networkId, requestedBy)) {
+                coreLogger.warn('Unauthorized modification attempt', {
+                    networkId,
+                    requestedBy,
+                    owner: vehicle.ownership.clientID,
+                });
+                return false;
+            }
+            if (!this.vehicleService.validateProximity(networkId, requestedBy, 15.0)) {
+                coreLogger.warn('Player too far from vehicle for modification', {
+                    networkId,
+                    requestedBy,
+                });
+                return false;
+            }
+        }
+        const validatedMods = this.validateMods(mods);
+        coreLogger.debug('Vehicle modifications applied', {
+            networkId,
+            requestedBy,
+            mods: Object.keys(validatedMods),
+        });
+        this.events.emit('opencore:vehicle:modified', 'all', {
+            networkId,
+            mods: validatedMods,
+        });
+        return true;
+    }
+    /**
+     * Sets vehicle colors with validation.
+     *
+     * @param networkId - Network ID of the vehicle
+     * @param primaryColor - Primary color ID
+     * @param secondaryColor - Secondary color ID
+     * @param requestedBy - Client ID requesting the change
+     * @returns Success status
+     */
+    setColors(networkId, primaryColor, secondaryColor, requestedBy) {
+        return this.applyModifications({
+            networkId,
+            mods: { primaryColor, secondaryColor },
+            requestedBy,
+        });
+    }
+    /**
+     * Sets vehicle livery with validation.
+     *
+     * @param networkId - Network ID of the vehicle
+     * @param livery - Livery index
+     * @param requestedBy - Client ID requesting the change
+     * @returns Success status
+     */
+    setLivery(networkId, livery, requestedBy) {
+        return this.applyModifications({
+            networkId,
+            mods: { livery },
+            requestedBy,
+        });
+    }
+    /**
+     * Toggles vehicle turbo with validation.
+     *
+     * @param networkId - Network ID of the vehicle
+     * @param enabled - Whether turbo should be enabled
+     * @param requestedBy - Client ID requesting the change
+     * @returns Success status
+     */
+    setTurbo(networkId, enabled, requestedBy) {
+        return this.applyModifications({
+            networkId,
+            mods: { turbo: enabled },
+            requestedBy,
+        });
+    }
+    /**
+     * Sets vehicle window tint with validation.
+     *
+     * @param networkId - Network ID of the vehicle
+     * @param tint - Tint level (0-6)
+     * @param requestedBy - Client ID requesting the change
+     * @returns Success status
+     */
+    setWindowTint(networkId, tint, requestedBy) {
+        const validTint = Math.max(0, Math.min(6, tint));
+        return this.applyModifications({
+            networkId,
+            mods: { windowTint: validTint },
+            requestedBy,
+        });
+    }
+    /**
+     * Sets vehicle neon lights with validation.
+     *
+     * @param networkId - Network ID of the vehicle
+     * @param enabled - Array of [left, right, front, back] enabled states
+     * @param color - RGB color array
+     * @param requestedBy - Client ID requesting the change
+     * @returns Success status
+     */
+    setNeon(networkId, enabled, color, requestedBy) {
+        const mods = { neonEnabled: enabled };
+        if (color) {
+            mods.neonColor = color;
+        }
+        return this.applyModifications({
+            networkId,
+            mods,
+            requestedBy,
+        });
+    }
+    /**
+     * Resets all modifications on a vehicle.
+     *
+     * @param networkId - Network ID of the vehicle
+     * @param requestedBy - Client ID requesting the reset
+     * @returns Success status
+     */
+    resetModifications(networkId, requestedBy) {
+        const vehicle = this.vehicleService.getByNetworkId(networkId);
+        if (!vehicle)
+            return false;
+        if (requestedBy !== undefined) {
+            if (!this.vehicleService.validateOwnership(networkId, requestedBy)) {
+                return false;
+            }
+        }
+        const defaultMods = {
+            spoiler: -1,
+            frontBumper: -1,
+            rearBumper: -1,
+            sideSkirt: -1,
+            exhaust: -1,
+            frame: -1,
+            grille: -1,
+            hood: -1,
+            fender: -1,
+            rightFender: -1,
+            roof: -1,
+            engine: -1,
+            brakes: -1,
+            transmission: -1,
+            horns: -1,
+            suspension: -1,
+            armor: -1,
+            turbo: false,
+            xenon: false,
+            windowTint: 0,
+        };
+        coreLogger.info('Vehicle modifications reset', { networkId, requestedBy });
+        this.events.emit('opencore:vehicle:modified', 'all', {
+            networkId,
+            mods: defaultMods,
+        });
+        return true;
+    }
+    /**
+     * Gets the current modifications of a vehicle.
+     *
+     * @param networkId - Network ID of the vehicle
+     * @returns Vehicle mods or undefined
+     */
+    getModifications(networkId) {
+        const vehicle = this.vehicleService.getByNetworkId(networkId);
+        return vehicle?.mods;
+    }
+    /**
+     * Validates modification values to prevent exploits.
+     *
+     * @param mods - Modifications to validate
+     * @returns Validated modifications
+     */
+    validateMods(mods) {
+        const validated = {};
+        const modSlots = [
+            'spoiler',
+            'frontBumper',
+            'rearBumper',
+            'sideSkirt',
+            'exhaust',
+            'frame',
+            'grille',
+            'hood',
+            'fender',
+            'rightFender',
+            'roof',
+            'engine',
+            'brakes',
+            'transmission',
+            'horns',
+            'suspension',
+            'armor',
+            'wheels',
+        ];
+        for (const slot of modSlots) {
+            if (mods[slot] !== undefined) {
+                const value = mods[slot];
+                validated[slot] = Math.max(-1, Math.min(50, value));
+            }
+        }
+        if (mods.turbo !== undefined)
+            validated.turbo = Boolean(mods.turbo);
+        if (mods.xenon !== undefined)
+            validated.xenon = Boolean(mods.xenon);
+        if (mods.wheelType !== undefined) {
+            validated.wheelType = Math.max(0, Math.min(12, mods.wheelType));
+        }
+        if (mods.windowTint !== undefined) {
+            validated.windowTint = Math.max(0, Math.min(6, mods.windowTint));
+        }
+        if (mods.livery !== undefined) {
+            validated.livery = Math.max(-1, Math.min(50, mods.livery));
+        }
+        if (mods.plateStyle !== undefined) {
+            validated.plateStyle = Math.max(0, Math.min(5, mods.plateStyle));
+        }
+        if (mods.primaryColor !== undefined) {
+            validated.primaryColor = Math.max(0, Math.min(160, mods.primaryColor));
+        }
+        if (mods.secondaryColor !== undefined) {
+            validated.secondaryColor = Math.max(0, Math.min(160, mods.secondaryColor));
+        }
+        if (mods.pearlescentColor !== undefined) {
+            validated.pearlescentColor = Math.max(0, Math.min(160, mods.pearlescentColor));
+        }
+        if (mods.wheelColor !== undefined) {
+            validated.wheelColor = Math.max(0, Math.min(160, mods.wheelColor));
+        }
+        if (mods.xenonColor !== undefined) {
+            validated.xenonColor = Math.max(0, Math.min(12, mods.xenonColor));
+        }
+        if (mods.neonEnabled !== undefined) {
+            validated.neonEnabled = mods.neonEnabled;
+        }
+        if (mods.neonColor !== undefined) {
+            validated.neonColor = [
+                Math.max(0, Math.min(255, mods.neonColor[0])),
+                Math.max(0, Math.min(255, mods.neonColor[1])),
+                Math.max(0, Math.min(255, mods.neonColor[2])),
+            ];
+        }
+        if (mods.extras !== undefined) {
+            validated.extras = {};
+            for (const [key, value] of Object.entries(mods.extras)) {
+                const extraId = Number(key);
+                if (extraId >= 0 && extraId <= 20) {
+                    validated.extras[extraId] = Boolean(value);
+                }
+            }
+        }
+        return validated;
+    }
+};
+VehicleModification = __decorate([
+    injectable(),
+    __param(0, inject(Vehicles)),
+    __param(1, inject(EventsAPI)),
+    __metadata("design:paramtypes", [Vehicles,
+        EventsAPI])
+], VehicleModification);
+export { VehicleModification };

package/dist/runtime/server/apis/vehicles.api.d.ts

@@ -0,0 +1,146 @@
+import { IHasher } from '../../../adapters/contracts/IHasher';
+import { EventsAPI } from '../../../adapters/contracts/transport/events.api';
+import { IEntityServer } from '../../../adapters/contracts/server/IEntityServer';
+import { IVehicleLifecycleServer } from '../../../adapters/contracts/server/vehicle-lifecycle/IVehicleLifecycleServer';
+import { IVehicleServer } from '../../../adapters/contracts/server/IVehicleServer';
+import { Vector3 } from '../../../kernel/utils/vector3';
+import { Player } from '../entities/player';
+import { Vehicle } from '../entities/vehicle';
+import { SerializedVehicleData, VehicleCreateOptions, VehicleSpawnResult } from '../types/vehicle.types';
+import { Players } from '../ports/players.api-port';
+export interface VehicleCreateForPlayerOptions extends Omit<VehicleCreateOptions, 'position' | 'ownership'> {
+    offset?: Vector3;
+    seatIndex?: number;
+}
+/**
+ * Server-side service for managing vehicle entities.
+ *
+ * This service is the central authority for all vehicle operations:
+ * - Creating vehicles server-side (prevents client-side spawning abuse)
+ * - Managing vehicle registry by Network ID
+ * - Validating permissions and positions
+ * - Synchronizing vehicle state across clients
+ *
+ * @remarks
+ * All vehicle creation MUST go through this service to ensure security.
+ * Uses CreateVehicleServerSetter for server-authoritative spawning.
+ */
+export declare class Vehicles {
+    private readonly playerDirectory;
+    private readonly entityServer;
+    private readonly vehicleServer;
+    private readonly vehicleLifecycle;
+    private readonly hasher;
+    private readonly events;
+    /**
+     * Internal registry of all managed vehicles indexed by Network ID
+     */
+    private vehiclesByNetworkId;
+    /**
+     * Cached adapters bundle for Vehicle instances
+     */
+    private readonly vehicleAdapters;
+    constructor(playerDirectory: Players, entityServer: IEntityServer, vehicleServer: IVehicleServer, vehicleLifecycle: IVehicleLifecycleServer, hasher: IHasher, events: EventsAPI<'server'>);
+    /**
+     * Creates a new vehicle on the server.
+     *
+     * This method uses CreateVehicleServerSetter to spawn the vehicle server-side,
+     * preventing client-side spawning exploits.
+     *
+     * @param options - Vehicle creation options
+     * @returns Spawn result with network ID and handle
+     */
+    create(options: VehicleCreateOptions): Promise<VehicleSpawnResult>;
+    /**
+     * Creates a vehicle for a specific player.
+     *
+     * @param clientID - Client ID of the requesting player
+     * @param options - Vehicle creation options
+     * @returns Spawn result
+     */
+    createForPlayer(playerOrClientID: Player | number, options: VehicleCreateForPlayerOptions): Promise<VehicleSpawnResult>;
+    private resolvePlayer;
+    private getSpawnPositionForPlayer;
+    /**
+     * Retrieves a vehicle by its Network ID.
+     *
+     * @param networkId - Network ID of the vehicle
+     * @returns Vehicle entity or undefined
+     */
+    getByNetworkId(networkId: number): Vehicle | undefined;
+    /**
+     * Retrieves a vehicle by its entity handle.
+     *
+     * @param handle - Entity handle
+     * @returns Vehicle entity or undefined
+     */
+    getByHandle(handle: number): Vehicle | undefined;
+    /**
+     * Gets all vehicles owned by a specific player.
+     *
+     * @param clientID - Client ID of the owner
+     * @returns Array of vehicles
+     */
+    getPlayerVehicles(clientID: number): Vehicle[];
+    /**
+     * Gets all vehicles in a specific routing bucket.
+     *
+     * @param bucket - Routing bucket ID
+     * @returns Array of vehicles
+     */
+    getVehiclesInBucket(bucket: number): Vehicle[];
+    /**
+     * Gets all managed vehicles.
+     *
+     * @returns Array of all vehicles
+     */
+    getAll(): Vehicle[];
+    /**
+     * Deletes a vehicle from the server.
+     *
+     * @param networkId - Network ID of the vehicle to delete
+     * @param requestedBy - Optional client ID for permission validation
+     * @returns Success status
+     */
+    delete(networkId: number, requestedBy?: number): boolean;
+    /**
+     * Deletes all vehicles owned by a player.
+     * Useful when a player disconnects.
+     *
+     * @param clientID - Client ID of the owner
+     */
+    deletePlayerVehicles(clientID: number): void;
+    /**
+     * Validates if a player can perform an action on a vehicle.
+     *
+     * @param networkId - Network ID of the vehicle
+     * @param clientID - Client ID of the player
+     * @returns True if authorized
+     */
+    validateOwnership(networkId: number, clientID: number): boolean;
+    /**
+     * Validates if a player is near a vehicle.
+     *
+     * @param networkId - Network ID of the vehicle
+     * @param clientID - Client ID of the player
+     * @param maxDistance - Maximum distance in units
+     * @returns True if within range
+     */
+    validateProximity(networkId: number, clientID: number, maxDistance?: number): boolean;
+    /**
+     * Cleans up orphaned vehicles that no longer exist.
+     */
+    cleanup(): void;
+    /**
+     * Gets the total count of managed vehicles.
+     *
+     * @returns Vehicle count
+     */
+    getCount(): number;
+    /**
+     * Serializes all vehicles for data transfer.
+     *
+     * @returns Array of serialized vehicle data
+     */
+    serializeAll(): SerializedVehicleData[];
+}