@open-core/framework 0.3.0 → 0.3.2

package/dist/runtime/server/bootstrap.js

@@ -162,23 +162,45 @@ async function initServer(options) {
     if (ctx.mode === 'CORE' &&
         index_1.GLOBAL_CONTAINER.isRegistered(adapters_1.IEngineEvents) &&
         index_1.GLOBAL_CONTAINER.isRegistered(adapters_1.INetTransport)) {
-        const engineEvents = index_1.GLOBAL_CONTAINER.resolve(adapters_1.IEngineEvents); // server -> servers
-        const net = index_1.GLOBAL_CONTAINER.resolve(adapters_1.INetTransport); // server -> clients
-        engineEvents.emit('core:ready'); // Broadcast to all Servers resources
-        net.emitNet('core:ready', 'all'); // Broadcast to all Clients resources
-        logger_1.loggers.bootstrap.debug(`'core:ready' events emmited to all clients and all servers`);
+        const engineEvents = index_1.GLOBAL_CONTAINER.resolve(adapters_1.IEngineEvents);
+        const net = index_1.GLOBAL_CONTAINER.resolve(adapters_1.INetTransport);
+        // 1. Broadast to resources already running
+        engineEvents.emit('core:ready');
+        net.emitNet('core:ready', 'all');
+        // 2. Listen for 'core:request-ready' for resources starting late (hot-reload)
+        engineEvents.on('core:request-ready', () => {
+            engineEvents.emit('core:ready');
+        });
+        logger_1.loggers.bootstrap.info(`'core:ready' logic initialized and broadcasted`);
     }
+    const logLevelLabel = logger_1.LogLevelLabels[(0, logger_1.getLogLevel)()];
+    logger_1.loggers.bootstrap.info(`LogLevel Setted: ${logLevelLabel}`);
 }
 function createCoreDependency(coreName) {
+    logger_1.loggers.bootstrap.debug(`Setting up detection mechanisms for Core '${coreName}'...`);
     return new Promise((resolve, reject) => {
         let resolved = false;
+        let pollingInterval;
+        let timeout;
         const engineEvents = index_1.GLOBAL_CONTAINER.resolve(adapters_1.IEngineEvents);
         const cleanup = () => {
             resolved = true;
-            clearTimeout(timeout);
-            clearInterval(pollingInterval);
+            if (timeout)
+                clearTimeout(timeout);
+            if (pollingInterval)
+                clearInterval(pollingInterval);
         };
-        // 1. Check if already ready via export (Polling)
+        // 1. Register listener FIRST (before any requests)
+        const onReady = () => {
+            if (!resolved) {
+                logger_1.loggers.bootstrap.debug(`Core '${coreName}' detected via 'core:ready' event!`);
+                cleanup();
+                resolve();
+            }
+        };
+        engineEvents.on('core:ready', onReady);
+        logger_1.loggers.bootstrap.debug(`Listening for 'core:ready' event from Core`);
+        // 2. Check if already ready via export (Polling)
         const checkReady = () => {
             var _a, _b;
             if (resolved)
@@ -186,34 +208,33 @@ function createCoreDependency(coreName) {
             try {
                 const globalExports = globalThis.exports;
                 const isReady = (_b = (_a = globalExports === null || globalExports === void 0 ? void 0 : globalExports[coreName]) === null || _a === void 0 ? void 0 : _a.isCoreReady) === null || _b === void 0 ? void 0 : _b.call(_a);
+                logger_1.loggers.bootstrap.debug(`Polling isCoreReady export: ${isReady}`);
                 if (isReady === true) {
-                    logger_1.loggers.bootstrap.debug(`Core '${coreName}' detected as already ready via export.`);
+                    logger_1.loggers.bootstrap.debug(`Core '${coreName}' detected via isCoreReady export!`);
                     cleanup();
                     resolve();
                 }
             }
-            catch (_c) {
-                // Core might not be started yet, ignore
+            catch (e) {
+                logger_1.loggers.bootstrap.debug(`Export check failed: ${e}`);
             }
         };
-        const pollingInterval = setInterval(checkReady, 500);
+        pollingInterval = setInterval(checkReady, 500);
         checkReady(); // Initial check
-        // 2. Timeout protection
-        const timeout = setTimeout(() => {
+        // 3. Request status (for hot-reload cases where Core is already up)
+        // This is sent AFTER registering the listener so we can receive the response
+        if (!resolved) {
+            logger_1.loggers.bootstrap.debug(`Requesting Core status via 'core:request-ready' event`);
+            engineEvents.emit('core:request-ready');
+        }
+        // 4. Timeout protection
+        timeout = setTimeout(() => {
             if (!resolved) {
+                logger_1.loggers.bootstrap.warn(`Timeout waiting for Core '${coreName}' after ${CORE_WAIT_TIMEOUT}ms`);
                 cleanup();
                 reject(new Error(`[OpenCore] Timeout waiting for CORE '${coreName}'. The Core did not emit 'core:ready' or expose 'isCoreReady' within ${CORE_WAIT_TIMEOUT}ms.`));
             }
         }, CORE_WAIT_TIMEOUT);
-        // 3. Listen for the event (for resources starting after/during CORE init)
-        const onReady = () => {
-            if (!resolved) {
-                logger_1.loggers.bootstrap.debug(`Core '${coreName}' detected via 'core:ready' event.`);
-                cleanup();
-                resolve();
-            }
-        };
-        engineEvents.on('core:ready', onReady);
     });
 }
 async function dependencyResolver(waitFor, onReady) {

package/dist/runtime/server/controllers/command-export.controller.js

@@ -159,12 +159,22 @@ let CommandExportController = class CommandExportController {
      * Exported as: `exports[coreResourceName].registerCommand`
      */
     registerCommand(metadata) {
-        var _a;
         const commandKey = metadata.command.toLowerCase();
-        if (this.remoteCommands.has(commandKey)) {
+        const existing = this.remoteCommands.get(commandKey);
+        if (existing) {
+            // Allow re-registration from the same resource (hot-reload scenario)
+            if (existing.resourceName === metadata.resourceName) {
+                logger_1.loggers.command.debug(`Re-registering command '${metadata.command}' from same resource (hot-reload)`, { command: metadata.command, resource: metadata.resourceName });
+                // Update the entry with new metadata
+                this.remoteCommands.set(commandKey, {
+                    metadata,
+                    resourceName: metadata.resourceName,
+                });
+                return;
+            }
             logger_1.loggers.command.warn(`Remote command '${metadata.command}' already registered`, {
                 command: metadata.command,
-                existingResource: (_a = this.remoteCommands.get(commandKey)) === null || _a === void 0 ? void 0 : _a.resourceName,
+                existingResource: existing.resourceName,
                 newResource: metadata.resourceName,
             });
             return;

package/dist/runtime/server/controllers/ready.controller.d.ts

@@ -1,5 +1,4 @@
 export declare class ReadyController {
     private isReady;
-    constructor();
     isCoreReady(): boolean;
 }

package/dist/runtime/server/controllers/ready.controller.js

@@ -14,11 +14,7 @@ const controller_1 = require("../decorators/controller");
 const export_1 = require("../decorators/export");
 let ReadyController = class ReadyController {
     constructor() {
-        this.isReady = false;
-        // Set ready after a small tick to ensure bootstrap finishes
-        setTimeout(() => {
-            this.isReady = true;
-        }, 0);
+        this.isReady = true;
     }
     isCoreReady() {
         return this.isReady;
@@ -32,6 +28,5 @@ __decorate([
     __metadata("design:returntype", Boolean)
 ], ReadyController.prototype, "isCoreReady", null);
 exports.ReadyController = ReadyController = __decorate([
-    (0, controller_1.Controller)(),
-    __metadata("design:paramtypes", [])
+    (0, controller_1.Controller)()
 ], ReadyController);

package/dist/runtime/server/controllers/remote-command-execution.controller.js

@@ -85,6 +85,11 @@ let RemoteCommandExecutionController = class RemoteCommandExecutionController {
      * @param args - Command arguments
      */
     async handleCommandExecution(clientID, commandName, args) {
+        logger_1.loggers.command.debug(`Received command execution request`, {
+            command: commandName,
+            clientID,
+            args,
+        });
         const player = this.playerDirectory.getByClient(clientID);
         if (!player) {
             logger_1.loggers.command.warn(`Command execution failed: player not found`, {
@@ -93,8 +98,17 @@ let RemoteCommandExecutionController = class RemoteCommandExecutionController {
             });
             return;
         }
+        logger_1.loggers.command.debug(`Executing command for player`, {
+            command: commandName,
+            playerName: player.name,
+            clientID,
+        });
         try {
             await this.commandService.execute(player, commandName, args);
+            logger_1.loggers.command.debug(`Command executed successfully`, {
+                command: commandName,
+                clientID,
+            });
         }
         catch (error) {
             // Do not notify the player here. Report through the global observer.

package/dist/runtime/server/decorators/command.d.ts

@@ -34,6 +34,8 @@ export interface CommandMetadata extends CommandConfig {
     isPublic?: boolean;
     /** Security metadata for remote validation */
     security?: SecurityMetadata;
+    /** True if the last parameter uses the spread operator (...args) */
+    hasSpreadParam?: boolean;
 }
 type ServerCommandHandler = (() => any) | ((player: Player, ...args: any[]) => any);
 /**

package/dist/runtime/server/decorators/command.js

@@ -24,9 +24,12 @@ function Command(configOrName, schema) {
             throw new Error(`@Command '${config.command}': first parameter must be Player if parameters are present`);
         }
         const paramNames = (0, function_helper_1.getParameterNames)(descriptor.value);
+        const spreadIndices = (0, function_helper_1.getSpreadParameterIndices)(descriptor.value);
+        const hasSpreadParam = spreadIndices.length > 0 && spreadIndices[spreadIndices.length - 1];
         const metadata = Object.assign(Object.assign({}, config), { methodName: propertyKey, target: target.constructor, paramTypes,
             paramNames,
-            expectsPlayer });
+            expectsPlayer,
+            hasSpreadParam });
         Reflect.defineMetadata(metadata_server_keys_1.METADATA_KEYS.COMMAND, metadata, target, propertyKey);
     };
 }

package/dist/runtime/server/helpers/command-validation.helper.d.ts

@@ -1,6 +1,3 @@
 import { CommandMetadata } from '../decorators/command';
 import { Player } from '../entities';
-/**
- * Centraliza validación de argumentos de comandos.
- */
 export declare function validateAndExecuteCommand(meta: CommandMetadata, player: Player, args: string[], handler: (...args: any[]) => any): Promise<any>;

package/dist/runtime/server/helpers/command-validation.helper.js

@@ -7,13 +7,10 @@ exports.validateAndExecuteCommand = validateAndExecuteCommand;
 const zod_1 = __importDefault(require("zod"));
 const kernel_1 = require("../../../kernel");
 const schema_generator_1 = require("../system/schema-generator");
-/**
- * Centraliza validación de argumentos de comandos.
- */
+const process_tuple_schema_1 = require("./process-tuple-schema");
 async function validateAndExecuteCommand(meta, player, args, handler) {
     const paramNames = meta.expectsPlayer ? meta.paramNames.slice(1) : meta.paramNames;
     let schema = meta.schema;
-    // Caso: comando sin player → no espera argumentos
     if (!meta.expectsPlayer) {
         if (args.length > 0) {
             throw new kernel_1.AppError('GAME:BAD_REQUEST', `Incorrect usage, use: ${meta.usage}`, 'client', {
@@ -22,7 +19,6 @@ async function validateAndExecuteCommand(meta, player, args, handler) {
         }
         return await handler();
     }
-    // Autogenerar esquema si no lo definieron
     if (!schema) {
         schema = (0, schema_generator_1.generateSchemaFromTypes)(meta.paramTypes);
         if (!schema) {
@@ -32,7 +28,6 @@ async function validateAndExecuteCommand(meta, player, args, handler) {
             return await handler(player);
         }
     }
-    // OBJETO schema
     if (schema instanceof zod_1.default.ZodObject) {
         const keys = Object.keys(schema.shape);
         for (const p of paramNames) {
@@ -60,12 +55,24 @@ async function validateAndExecuteCommand(meta, player, args, handler) {
     }
     // TUPLA schema
     if (schema instanceof zod_1.default.ZodTuple) {
-        const validated = await schema.parseAsync(args).catch(() => {
+        const processedArgs = (0, process_tuple_schema_1.processTupleSchema)(schema, args);
+        const validated = await schema.parseAsync(processedArgs).catch(() => {
             throw new kernel_1.AppError('GAME:BAD_REQUEST', `Incorrect usage, use: ${meta.usage}`, 'client', {
                 usage: meta.usage,
             });
         });
-        return await handler(player, ...validated);
+        const finalArgs = validated;
+        // If the handler uses spread operator (...args), flatten the last array argument
+        // so the handler receives individual arguments instead of a single array.
+        if (meta.hasSpreadParam &&
+            finalArgs.length > 0 &&
+            Array.isArray(finalArgs[finalArgs.length - 1])) {
+            const positional = finalArgs.slice(0, finalArgs.length - 1);
+            const rest = finalArgs[finalArgs.length - 1];
+            return await handler(player, ...positional, ...rest);
+        }
+        // For regular array parameters (args: string[]), pass as-is
+        return await handler(player, ...finalArgs);
     }
     // fallback
     return await handler(player);

package/dist/runtime/server/helpers/function-helper.d.ts

@@ -1 +1,6 @@
 export declare function getParameterNames(func: (...args: any[]) => any): string[];
+/**
+ * Detects which parameter indices use the spread operator (...args).
+ * Returns an array of booleans where true means the parameter at that index is a spread parameter.
+ */
+export declare function getSpreadParameterIndices(func: (...args: any[]) => any): boolean[];

package/dist/runtime/server/helpers/function-helper.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getParameterNames = getParameterNames;
+exports.getSpreadParameterIndices = getSpreadParameterIndices;
 function getParameterNames(func) {
     const stripped = func
         .toString()
@@ -13,3 +14,19 @@ function getParameterNames(func) {
         .filter(Boolean);
     return args;
 }
+/**
+ * Detects which parameter indices use the spread operator (...args).
+ * Returns an array of booleans where true means the parameter at that index is a spread parameter.
+ */
+function getSpreadParameterIndices(func) {
+    const stripped = func
+        .toString()
+        .replace(/\/\/.*$/gm, '')
+        .replace(/\/\*[\s\S]*?\*\//gm, '');
+    const argsString = stripped.slice(stripped.indexOf('(') + 1, stripped.indexOf(')'));
+    const args = argsString
+        .split(',')
+        .map((arg) => arg.trim())
+        .filter(Boolean);
+    return args.map((arg) => arg.startsWith('...'));
+}

package/dist/runtime/server/helpers/process-tuple-schema.d.ts

@@ -0,0 +1,20 @@
+import z from 'zod';
+/**
+ * Processes tuple schema validation with greedy handling for rest parameters.
+ *
+ * This function handles two cases:
+ * 1. If last parameter is ZodArray and there are MORE args than schema items,
+ *    collect the extra args into the array position.
+ * 2. If last parameter is ZodString and there are MORE args than schema items,
+ *    join the extra args into a single string.
+ *
+ * Examples:
+ * - handler(player, action: string, ...rest: string[]) with args ["hello", "world", "!"]
+ *   → schema is [z.string(), z.array(z.string())] (2 items)
+ *   → args has 3 items, so we group extra: ["hello", ["world", "!"]]
+ *
+ * - handler(player, command: string, args: string[]) with args ["vida", ["arg1"]]
+ *   → schema is [z.string(), z.array(z.string())] (2 items)
+ *   → args has 2 items, matches schema, no processing needed
+ */
+export declare function processTupleSchema(schema: z.ZodTuple, args: any[]): any[];

package/dist/runtime/server/helpers/process-tuple-schema.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processTupleSchema = processTupleSchema;
+const zod_1 = __importDefault(require("zod"));
+/**
+ * Processes tuple schema validation with greedy handling for rest parameters.
+ *
+ * This function handles two cases:
+ * 1. If last parameter is ZodArray and there are MORE args than schema items,
+ *    collect the extra args into the array position.
+ * 2. If last parameter is ZodString and there are MORE args than schema items,
+ *    join the extra args into a single string.
+ *
+ * Examples:
+ * - handler(player, action: string, ...rest: string[]) with args ["hello", "world", "!"]
+ *   → schema is [z.string(), z.array(z.string())] (2 items)
+ *   → args has 3 items, so we group extra: ["hello", ["world", "!"]]
+ *
+ * - handler(player, command: string, args: string[]) with args ["vida", ["arg1"]]
+ *   → schema is [z.string(), z.array(z.string())] (2 items)
+ *   → args has 2 items, matches schema, no processing needed
+ */
+function processTupleSchema(schema, args) {
+    const items = schema.description ? [] : schema._def.items;
+    if (items.length === 0) {
+        return args;
+    }
+    const lastItem = items[items.length - 1];
+    const positionalCount = items.length - 1;
+    // Case: More args than items (Greedy grouping)
+    if (args.length > items.length) {
+        // If last parameter is a string, join extra args with space
+        if (lastItem instanceof zod_1.default.ZodString) {
+            const positional = args.slice(0, positionalCount);
+            const restString = args.slice(positionalCount).join(' ');
+            return [...positional, restString];
+        }
+        // If last parameter is an array, we keep them as individual elements
+        // for the handler's spread operator (...args) or just as the array itself
+        // if ZodTuple is being used to parse.
+        // However, to avoid nesting [arg1, [arg2, arg3]], we return them flat
+        // if the handler expects a spread, OR we return the array if it's a single param.
+        if (lastItem instanceof zod_1.default.ZodArray) {
+            // For ZodTuple.parse() to work with a ZodArray at the end,
+            // it actually expects the array as a single element in that position.
+            const positional = args.slice(0, positionalCount);
+            const restArray = args.slice(positionalCount);
+            return [...positional, restArray];
+        }
+    }
+    // Case: Exact match but last is array
+    if (args.length === items.length) {
+        if (lastItem instanceof zod_1.default.ZodArray && !Array.isArray(args[positionalCount])) {
+            const positional = args.slice(0, positionalCount);
+            return [...positional, [args[positionalCount]]];
+        }
+    }
+    return args;
+}

package/dist/runtime/server/services/remote/remote-command.service.js

@@ -72,20 +72,35 @@ let RemoteCommandService = class RemoteCommandService extends command_execution_
     register(metadata, handler) {
         var _a, _b, _c, _d;
         const commandKey = metadata.command.toLowerCase();
+        const resourceName = GetCurrentResourceName();
+        logger_1.loggers.command.debug(`Registering command locally`, {
+            command: metadata.command,
+            resource: resourceName,
+        });
         // Store handler with full metadata locally (for schema validation)
         this.commands.set(commandKey, {
             meta: metadata,
             handler,
         });
         // Register metadata with CORE (security only, schema is not serializable)
-        this.core.registerCommand({
-            command: metadata.command,
-            description: metadata.description,
-            usage: metadata.usage,
-            isPublic: (_a = metadata.isPublic) !== null && _a !== void 0 ? _a : false,
-            resourceName: GetCurrentResourceName(),
-            security: metadata.security,
-        });
+        try {
+            this.core.registerCommand({
+                command: metadata.command,
+                description: metadata.description,
+                usage: metadata.usage,
+                isPublic: (_a = metadata.isPublic) !== null && _a !== void 0 ? _a : false,
+                resourceName,
+                security: metadata.security,
+            });
+        }
+        catch (e) {
+            logger_1.loggers.command.error(`Failed to register command with CORE`, {
+                command: metadata.command,
+                resource: resourceName,
+                error: e,
+            });
+            return;
+        }
         const publicFlag = metadata.isPublic ? ' [Public]' : '';
         const schemaFlag = metadata.schema ? ' [Validated]' : '';
         const securityFlags = [];

package/dist/runtime/server/system/processors/netEvent.processor.js

@@ -23,6 +23,7 @@ const INetTransport_1 = require("../../../../adapters/contracts/INetTransport");
 const logger_1 = require("../../../../kernel/logger");
 const net_event_security_observer_contract_1 = require("../../contracts/security/net-event-security-observer.contract");
 const security_handler_contract_1 = require("../../contracts/security/security-handler.contract");
+const process_tuple_schema_1 = require("../../helpers/process-tuple-schema");
 const resolve_method_1 = require("../../helpers/resolve-method");
 const player_directory_port_1 = require("../../services/ports/player-directory.port");
 const metadata_server_keys_1 = require("../metadata-server.keys");
@@ -81,7 +82,8 @@ let NetEventProcessor = class NetEventProcessor {
             }
             try {
                 if (schema instanceof zod_1.default.ZodTuple) {
-                    validatedArgs = schema.parse(args);
+                    const processedArgs = (0, process_tuple_schema_1.processTupleSchema)(schema, args);
+                    validatedArgs = schema.parse(processedArgs);
                 }
                 else {
                     if (args.length !== 1) {

package/dist/runtime/server/system/schema-generator.js

@@ -18,7 +18,9 @@ function typeToZodSchema(type) {
         case Boolean:
             return zod_1.default.coerce.boolean();
         case Array:
-            return zod_1.default.array(zod_1.default.any());
+            // Command/event arguments are always strings, so Array means string[]
+            // This enables spread operator support: handler(player: Player, ...args: string[])
+            return zod_1.default.array(zod_1.default.string());
         case Object:
             return undefined;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-core/framework",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Secure, Event-Driven, OOP Engine for FiveM. Stop scripting, start engineering.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",