@open-core/framework 0.3.2 → 0.3.3

package/README.md

@@ -19,17 +19,7 @@ It is not a gamemode or RP framework. It provides:
 
 License: MPL-2.0
 
-[Discord Community](https://discord.gg/99g3FgvkPs) | [Website](https://opencorejs.dev) | [OpenCore CLI](https://github.com/newcore-network/opencore-cli)
-
-## Scope
-
-This package (`@open-core/framework`) contains transversal infrastructure only.
-
-- Controllers, services, decorators, and processors
-- Session/lifecycle primitives and contracts
-- Adapters and capability registration
-
-Gameplay logic must live in separate resources/modules.
+[Discord Community](https://discord.gg/99g3FgvkPs) | [Docs](https://opencorejs.dev) | [OpenCore CLI](https://github.com/newcore-network/opencore-cli)
 
 ## Installation
 
@@ -46,13 +36,11 @@ The package exposes subpath entry points:
 - `@open-core/framework` (root)
 - `@open-core/framework/server`
 - `@open-core/framework/client`
-- `@open-core/framework/shared`
-- `@open-core/framework/utils`
 
 Most projects will import the `Server`/`Client` namespaces:
 
 ```ts
-import { Server } from '@open-core/framework'
+import { Server } from '@open-core/framework/server'
 ```
 
 ## Architecture
@@ -81,11 +69,7 @@ Initialize the server runtime:
 import { Server } from '@open-core/framework/server'
 
 await Server.init({
-  mode: 'STANDALONE',
-  features: {
-    commands: { enabled: true },
-    netEvents: { enabled: true },
-  },
+  mode: 'CORE'
 })
 ```
 
@@ -95,7 +79,6 @@ Some features require providers (depending on your mode and configuration). Conf
 import { Server } from '@open-core/framework/server'
 
 Server.setPrincipalProvider(MyPrincipalProvider)
-Server.setAuthProvider(MyAuthProvider)
 Server.setSecurityHandler(MySecurityHandler)
 Server.setPersistenceProvider(MyPlayerPersistence)
 Server.setNetEventSecurityObserver(MyNetEventSecurityObserver)

package/dist/adapters/contracts/IResourceInfo.d.ts

@@ -1,3 +1,4 @@
 export declare abstract class IResourceInfo {
     abstract getCurrentResourceName(): string;
+    abstract getCurrentResourcePath(): string;
 }

package/dist/adapters/fivem/fivem-resourceinfo.d.ts

@@ -1,4 +1,5 @@
 import { IResourceInfo } from '../contracts/IResourceInfo';
 export declare class FiveMResourceInfo extends IResourceInfo {
     getCurrentResourceName(): string;
+    getCurrentResourcePath(): string;
 }

package/dist/adapters/fivem/fivem-resourceinfo.js

@@ -12,5 +12,17 @@ class FiveMResourceInfo extends IResourceInfo_1.IResourceInfo {
         }
         return 'default';
     }
+    getCurrentResourcePath() {
+        const fn = globalThis.GetResourcePath;
+        if (typeof fn === 'function') {
+            const name = this.getCurrentResourceName();
+            if (name) {
+                const path = fn(name);
+                if (typeof path === 'string' && path.trim())
+                    return path;
+            }
+        }
+        return process.cwd();
+    }
 }
 exports.FiveMResourceInfo = FiveMResourceInfo;

package/dist/adapters/node/node-resourceinfo.d.ts

@@ -9,4 +9,5 @@ import { IResourceInfo } from '../contracts/IResourceInfo';
  */
 export declare class NodeResourceInfo implements IResourceInfo {
     getCurrentResourceName(): string;
+    getCurrentResourcePath(): string;
 }

package/dist/adapters/node/node-resourceinfo.js

@@ -20,6 +20,9 @@ let NodeResourceInfo = class NodeResourceInfo {
     getCurrentResourceName() {
         return process.env.RESOURCE_NAME || 'default';
     }
+    getCurrentResourcePath() {
+        return process.env.RESOURCE_PATH || process.cwd();
+    }
 };
 exports.NodeResourceInfo = NodeResourceInfo;
 exports.NodeResourceInfo = NodeResourceInfo = __decorate([

package/dist/kernel/di/container.d.ts

@@ -1,4 +1,5 @@
 /**
  * This is the global container for tsyringe, it contains all the dependencies to resolve, etc. Please use with caution.
+ *  When you use in Server is the server-side container ONLY, if you use in Client is ONLY the container of client-side
  */
 export declare const GLOBAL_CONTAINER: import("tsyringe").DependencyContainer;

package/dist/kernel/di/container.js

@@ -4,5 +4,6 @@ exports.GLOBAL_CONTAINER = void 0;
 const tsyringe_1 = require("tsyringe");
 /**
  * This is the global container for tsyringe, it contains all the dependencies to resolve, etc. Please use with caution.
+ *  When you use in Server is the server-side container ONLY, if you use in Client is ONLY the container of client-side
  */
 exports.GLOBAL_CONTAINER = tsyringe_1.container;

package/dist/kernel/index.d.ts

@@ -1,4 +1,4 @@
-export { GLOBAL_CONTAINER } from './di/container';
+export * from './di/container';
 export * from './error';
 export * from './logger';
 export * from './schema';

package/dist/kernel/index.js

@@ -14,10 +14,8 @@ 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.GLOBAL_CONTAINER = void 0;
 // External to export
-var container_1 = require("./di/container");
-Object.defineProperty(exports, "GLOBAL_CONTAINER", { enumerable: true, get: function () { return container_1.GLOBAL_CONTAINER; } });
+__exportStar(require("./di/container"), exports);
 __exportStar(require("./error"), exports);
 __exportStar(require("./logger"), exports);
 __exportStar(require("./schema"), exports);

package/dist/runtime/server/bootstrap.js

@@ -39,10 +39,13 @@ const register_capabilities_1 = require("../../adapters/register-capabilities");
 const index_1 = require("../../kernel/di/index");
 const logger_1 = require("../../kernel/logger");
 const index_2 = require("./contracts/index");
+const binary_service_1 = require("./decorators/binary-service");
 const controller_1 = require("./decorators/controller");
 const runtime_1 = require("./runtime");
+const binary_process_manager_1 = require("./services/binary/binary-process.manager");
 const session_recovery_service_1 = require("./services/core/session-recovery.service");
 const services_register_1 = require("./services/services.register");
+const metadata_server_keys_1 = require("./system/metadata-server.keys");
 const processors_register_1 = require("./system/processors.register");
 const CORE_WAIT_TIMEOUT = 10000;
 function checkProviders(ctx) {
@@ -150,6 +153,22 @@ async function initServer(options) {
     checkProviders(ctx);
     const scanner = index_1.GLOBAL_CONTAINER.resolve(index_1.MetadataScanner);
     scanner.scan((0, controller_1.getServerControllerRegistry)());
+    const binaryServices = (0, binary_service_1.getServerBinaryServiceRegistry)();
+    for (const serviceClass of binaryServices) {
+        const metadata = Reflect.getMetadata(metadata_server_keys_1.METADATA_KEYS.BINARY_SERVICE, serviceClass);
+        if (!metadata)
+            continue;
+        const manager = index_1.GLOBAL_CONTAINER.resolve(binary_process_manager_1.BinaryProcessManager);
+        try {
+            manager.register(metadata, metadata.serviceClass);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger_1.loggers.bootstrap.error(`[BinaryService] Failed to register ${metadata.name}`, {
+                error: message,
+            });
+        }
+    }
     // Initialize DevMode if enabled
     if ((_d = ctx.devMode) === null || _d === void 0 ? void 0 : _d.enabled) {
         await initDevMode(ctx.devMode);

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

@@ -79,6 +79,8 @@ let CommandExportController = class CommandExportController {
                 logger_1.loggers.command.warn(`Rejected suspicious command: ${command}`, {
                     playerId: player.clientID,
                     playerName: player.name,
+                    accountID: player.accountID,
+                    args: args,
                 });
                 return;
             }

package/dist/runtime/server/decorators/binary-call.d.ts

@@ -0,0 +1,15 @@
+export interface BinaryCallOptions {
+    action?: string;
+    timeoutMs?: number;
+    service?: string;
+}
+/**
+ * marks a method as a remote binary action executed by a BinaryService. When a method decorated with @BinaryCall is invoked, its implementation is never executed locally. Instead, OpenCore replaces the method at runtime with an asynchronous proxy that:
+ * - Serializes the method arguments
+ * - Sends a request to the associated binary process
+ * - Waits for a response
+ * - Resolves or rejects the returned Promise
+ *
+ * From the developer’s perspective, the method behaves like a normal async function, while the actual logic is executed externally.
+ */
+export declare function BinaryCall(options?: BinaryCallOptions): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;

package/dist/runtime/server/decorators/binary-call.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryCall = BinaryCall;
+const metadata_server_keys_1 = require("../system/metadata-server.keys");
+/**
+ * marks a method as a remote binary action executed by a BinaryService. When a method decorated with @BinaryCall is invoked, its implementation is never executed locally. Instead, OpenCore replaces the method at runtime with an asynchronous proxy that:
+ * - Serializes the method arguments
+ * - Sends a request to the associated binary process
+ * - Waits for a response
+ * - Resolves or rejects the returned Promise
+ *
+ * From the developer’s perspective, the method behaves like a normal async function, while the actual logic is executed externally.
+ */
+function BinaryCall(options = {}) {
+    return (target, propertyKey, descriptor) => {
+        var _a;
+        if (!descriptor.value) {
+            throw new Error(`@BinaryCall(): descriptor.value is undefined for method '${propertyKey}'`);
+        }
+        Reflect.defineMetadata(metadata_server_keys_1.METADATA_KEYS.BINARY_CALL, {
+            methodName: propertyKey,
+            action: (_a = options.action) !== null && _a !== void 0 ? _a : propertyKey,
+            timeoutMs: options.timeoutMs,
+            service: options.service,
+        }, target, propertyKey);
+    };
+}

package/dist/runtime/server/decorators/binary-service.d.ts

@@ -0,0 +1,27 @@
+import { ClassConstructor } from '../../../kernel/di/class-constructor';
+export interface BinaryServiceOptions {
+    /** Logical identifier of the service inside OpenCore. This name is used to route binary calls and must be unique per resource. */
+    name: string;
+    /** Logical binary filename (without extension). The framework resolves the correct executable automatically depending on the platform */
+    binary: string;
+    /**
+     * Default timeout for binary calls in milliseconds. If the binary does not respond within this time, the call is rejected automatically.
+     */
+    timeoutMs?: number;
+}
+export interface BinaryServiceMetadata extends BinaryServiceOptions {
+    serviceClass: ClassConstructor;
+}
+export declare const _serverBinaryServiceRegistryByResource: Map<string, Set<ClassConstructor>>;
+export declare function getServerBinaryServiceRegistry(resourceName?: string): ClassConstructor[];
+/**
+ * Declares a native external binary service managed by OpenCore.
+ * A BinaryService represents a persistent operating system process executed outside the FiveM runtime, allowing heavy or sensitive logic to run in complete isolation while being consumed from TypeScript as normal asynchronous methods.
+ * Binary services communicate with OpenCore using a simple JSON-based RPC protocol over stdin / stdout.
+ *
+ * @remarks
+ * - The binary name is logical (no extensions). The framework resolves platform-specific files.
+ * - A single process is spawned and kept alive for the resource lifecycle.
+ * - This system is language-agnostic and can be implemented in any language capable of reading from standard input and writing to standard output.
+ */
+export declare function BinaryService(options: BinaryServiceOptions): (target: ClassConstructor) => void;

package/dist/runtime/server/decorators/binary-service.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._serverBinaryServiceRegistryByResource = void 0;
+exports.getServerBinaryServiceRegistry = getServerBinaryServiceRegistry;
+exports.BinaryService = BinaryService;
+const node_path_1 = __importDefault(require("node:path"));
+const metadata_server_keys_1 = require("../system/metadata-server.keys");
+const bind_1 = require("./bind");
+exports._serverBinaryServiceRegistryByResource = new Map();
+function getCurrentResourceNameSafe() {
+    const fn = globalThis.GetCurrentResourceName;
+    if (typeof fn === 'function') {
+        const name = fn();
+        if (typeof name === 'string' && name.trim())
+            return name;
+    }
+    return 'default';
+}
+function getServerBinaryServiceRegistry(resourceName) {
+    const key = resourceName !== null && resourceName !== void 0 ? resourceName : getCurrentResourceNameSafe();
+    let registry = exports._serverBinaryServiceRegistryByResource.get(key);
+    if (!registry) {
+        registry = new Set();
+        exports._serverBinaryServiceRegistryByResource.set(key, registry);
+    }
+    return Array.from(registry);
+}
+function assertValidBinaryName(binary) {
+    if (!binary || !binary.trim()) {
+        throw new Error('[OpenCore] BinaryService requires a non-empty binary name');
+    }
+    if (binary.includes('.') || node_path_1.default.extname(binary)) {
+        throw new Error(`[OpenCore] BinaryService binary name must not include extensions: ${binary}`);
+    }
+    if (/[/\\]/.test(binary)) {
+        throw new Error(`[OpenCore] BinaryService binary name must not include path separators: ${binary}`);
+    }
+    if (!/^[a-zA-Z0-9_-]+$/.test(binary)) {
+        throw new Error(`[OpenCore] BinaryService binary name has invalid characters: ${binary}`);
+    }
+}
+function assertValidServiceName(name) {
+    if (!name || !name.trim()) {
+        throw new Error('[OpenCore] BinaryService requires a non-empty service name');
+    }
+}
+/**
+ * Declares a native external binary service managed by OpenCore.
+ * A BinaryService represents a persistent operating system process executed outside the FiveM runtime, allowing heavy or sensitive logic to run in complete isolation while being consumed from TypeScript as normal asynchronous methods.
+ * Binary services communicate with OpenCore using a simple JSON-based RPC protocol over stdin / stdout.
+ *
+ * @remarks
+ * - The binary name is logical (no extensions). The framework resolves platform-specific files.
+ * - A single process is spawned and kept alive for the resource lifecycle.
+ * - This system is language-agnostic and can be implemented in any language capable of reading from standard input and writing to standard output.
+ */
+function BinaryService(options) {
+    return (target) => {
+        assertValidServiceName(options.name);
+        assertValidBinaryName(options.binary);
+        (0, bind_1.Bind)('singleton')(target);
+        const metadata = Object.assign(Object.assign({}, options), { serviceClass: target });
+        Reflect.defineMetadata(metadata_server_keys_1.METADATA_KEYS.BINARY_SERVICE, metadata, target);
+        Reflect.defineMetadata(metadata_server_keys_1.METADATA_KEYS.BINARY_SERVICE_NAME, metadata.name, target);
+        const key = getCurrentResourceNameSafe();
+        let registry = exports._serverBinaryServiceRegistryByResource.get(key);
+        if (!registry) {
+            registry = new Set();
+            exports._serverBinaryServiceRegistryByResource.set(key, registry);
+        }
+        registry.add(target);
+    };
+}

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

@@ -1,3 +1,5 @@
+export * from './binary-call';
+export * from './binary-service';
 export * from './bind';
 export { Command, CommandConfig } from './command';
 export { Controller } from './controller';

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

@@ -15,6 +15,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Controller = exports.Command = void 0;
+__exportStar(require("./binary-call"), exports);
+__exportStar(require("./binary-service"), exports);
 __exportStar(require("./bind"), exports);
 var command_1 = require("./command");
 Object.defineProperty(exports, "Command", { enumerable: true, get: function () { return command_1.Command; } });

package/dist/runtime/server/services/binary/binary-process.manager.d.ts

@@ -0,0 +1,17 @@
+import { IResourceInfo } from '../../../../adapters/contracts/IResourceInfo';
+import { BinaryServiceOptions } from '../../decorators/binary-service';
+export declare class BinaryProcessManager {
+    private resourceInfo;
+    private services;
+    constructor(resourceInfo: IResourceInfo);
+    register(options: BinaryServiceOptions, serviceClass: new (...args: any[]) => any): void;
+    call(serviceName: string, action: string, params: unknown[], timeoutMs?: number): Promise<unknown>;
+    private resolveServiceInstance;
+    private applyBinaryProxies;
+    private resolveBinaryPath;
+    private spawnProcess;
+    private handleStdout;
+    private handleResponse;
+    private failPending;
+    private writeLine;
+}

package/dist/runtime/server/services/binary/binary-process.manager.js

@@ -0,0 +1,273 @@
+"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;
+};
+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); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryProcessManager = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_events_1 = require("node:events");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const tsyringe_1 = require("tsyringe");
+const uuid_1 = require("uuid");
+const IResourceInfo_1 = require("../../../../adapters/contracts/IResourceInfo");
+const container_1 = require("../../../../kernel/di/container");
+const app_error_1 = require("../../../../kernel/error/app.error");
+const logger_1 = require("../../../../kernel/logger");
+const metadata_server_keys_1 = require("../../system/metadata-server.keys");
+const DEFAULT_TIMEOUT_MS = 15000;
+let BinaryProcessManager = class BinaryProcessManager {
+    constructor(resourceInfo) {
+        this.resourceInfo = resourceInfo;
+        this.services = new Map();
+    }
+    register(options, serviceClass) {
+        var _a;
+        if (this.services.has(options.name)) {
+            logger_1.loggers.bootstrap.warn(`[BinaryService] Duplicate service name skipped`, {
+                name: options.name,
+            });
+            return;
+        }
+        const entry = {
+            name: options.name,
+            binary: options.binary,
+            timeoutMs: (_a = options.timeoutMs) !== null && _a !== void 0 ? _a : DEFAULT_TIMEOUT_MS,
+            status: 'offline',
+            pending: new Map(),
+            buffer: '',
+            serviceClass,
+        };
+        this.services.set(options.name, entry);
+        logger_1.loggers.bootstrap.debug(`[BinaryService] Registered service`, {
+            name: options.name,
+            binary: options.binary,
+        });
+        const instance = this.resolveServiceInstance(serviceClass);
+        this.applyBinaryProxies(instance, options);
+        const binaryPath = this.resolveBinaryPath(options.binary);
+        if (!binaryPath) {
+            entry.status = 'missing';
+            logger_1.loggers.bootstrap.error(`[BinaryService] Binary not found`, {
+                name: options.name,
+                binary: options.binary,
+            });
+            return;
+        }
+        entry.binaryPath = binaryPath;
+        logger_1.loggers.bootstrap.debug(`[BinaryService] Resolved binary path`, {
+            name: options.name,
+            path: binaryPath,
+        });
+        this.spawnProcess(entry);
+    }
+    async call(serviceName, action, params, timeoutMs) {
+        const entry = this.services.get(serviceName);
+        if (!entry || entry.status !== 'online' || !entry.process) {
+            throw new app_error_1.AppError('COMMON:UNKNOWN', `[OpenCore] BinaryService '${serviceName}' is not available`, 'server');
+        }
+        const id = (0, uuid_1.v4)();
+        const payload = JSON.stringify({ id, action, params });
+        logger_1.loggers.bootstrap.debug(`[BinaryService] Calling action`, { service: serviceName, action, id });
+        await this.writeLine(entry, payload);
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                entry.pending.delete(id);
+                logger_1.loggers.bootstrap.error(`[BinaryService] Call timeout`, {
+                    service: serviceName,
+                    action,
+                    id,
+                    timeoutMs: timeoutMs !== null && timeoutMs !== void 0 ? timeoutMs : entry.timeoutMs,
+                });
+                reject(new app_error_1.AppError('COMMON:UNKNOWN', `[OpenCore] BinaryService '${serviceName}' call timeout`, 'server'));
+            }, timeoutMs !== null && timeoutMs !== void 0 ? timeoutMs : entry.timeoutMs);
+            entry.pending.set(id, {
+                resolve,
+                reject,
+                timeout,
+            });
+        });
+    }
+    resolveServiceInstance(serviceClass) {
+        return container_1.GLOBAL_CONTAINER.resolve(serviceClass);
+    }
+    applyBinaryProxies(instance, options) {
+        var _a;
+        const proto = Object.getPrototypeOf(instance);
+        const methodNames = Object.getOwnPropertyNames(proto).filter((name) => name !== 'constructor' && typeof instance[name] === 'function');
+        for (const methodName of methodNames) {
+            const metadata = Reflect.getMetadata(metadata_server_keys_1.METADATA_KEYS.BINARY_CALL, proto, methodName);
+            if (!metadata)
+                continue;
+            const serviceName = (_a = metadata.service) !== null && _a !== void 0 ? _a : options.name;
+            instance[methodName] = async (...args) => {
+                var _a;
+                return this.call(serviceName, metadata.action, args, (_a = metadata.timeoutMs) !== null && _a !== void 0 ? _a : options.timeoutMs);
+            };
+        }
+    }
+    resolveBinaryPath(binary) {
+        const resourceRoot = this.resourceInfo.getCurrentResourcePath();
+        const platform = process.platform;
+        const filename = platform === 'win32' ? `${binary}.exe` : binary;
+        const paths = [
+            node_path_1.default.join(resourceRoot, 'bin', platform, filename),
+            node_path_1.default.join(resourceRoot, 'bin', filename),
+            node_path_1.default.join(resourceRoot, filename),
+        ];
+        for (const p of paths) {
+            if (node_fs_1.default.existsSync(p))
+                return p;
+        }
+        return null;
+    }
+    spawnProcess(entry) {
+        if (!entry.binaryPath) {
+            entry.status = 'missing';
+            return;
+        }
+        const child = (0, node_child_process_1.spawn)(entry.binaryPath, [], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        entry.process = child;
+        entry.status = 'online';
+        logger_1.loggers.bootstrap.debug(`[BinaryService] Process spawned`, { name: entry.name, pid: child.pid });
+        child.stdout.on('data', (chunk) => this.handleStdout(entry, chunk));
+        child.stderr.on('data', (chunk) => {
+            logger_1.loggers.bootstrap.warn(`[BinaryService] ${entry.name} stderr`, {
+                message: chunk.toString(),
+            });
+        });
+        child.on('exit', (code, signal) => {
+            entry.status = 'offline';
+            this.failPending(entry, `Process exited (code=${code}, signal=${signal})`);
+            logger_1.loggers.bootstrap.error(`[BinaryService] ${entry.name} exited`, {
+                code,
+                signal,
+            });
+        });
+        child.on('error', (error) => {
+            entry.status = 'offline';
+            this.failPending(entry, error.message);
+            logger_1.loggers.bootstrap.error(`[BinaryService] ${entry.name} process error`, {
+                error: error.message,
+            });
+        });
+        logger_1.loggers.bootstrap.info(`[BinaryService] ${entry.name} started`, {
+            binary: entry.binaryPath,
+        });
+    }
+    handleStdout(entry, chunk) {
+        entry.buffer += chunk.toString();
+        let newlineIndex = entry.buffer.indexOf('\n');
+        while (newlineIndex !== -1) {
+            const line = entry.buffer.slice(0, newlineIndex);
+            entry.buffer = entry.buffer.slice(newlineIndex + 1);
+            const trimmed = line.trim();
+            if (trimmed) {
+                this.handleResponse(entry, trimmed);
+            }
+            newlineIndex = entry.buffer.indexOf('\n');
+        }
+    }
+    handleResponse(entry, rawLine) {
+        let response = null;
+        try {
+            response = JSON.parse(rawLine);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                logger_1.loggers.bootstrap.warn(`[BinaryService] ${entry.name} invalid JSON response`, {
+                    line: rawLine,
+                    error: error.message,
+                });
+            }
+            else {
+                logger_1.loggers.bootstrap.warn(`[BinaryService] ${entry.name} invalid JSON response`, {
+                    line: rawLine,
+                    error: `unknown error: ${error}`,
+                });
+            }
+            return;
+        }
+        if (!(response === null || response === void 0 ? void 0 : response.id)) {
+            logger_1.loggers.bootstrap.warn(`[BinaryService] ${entry.name} response missing id`, {
+                response,
+            });
+            return;
+        }
+        const pending = entry.pending.get(response.id);
+        if (!pending) {
+            logger_1.loggers.bootstrap.warn(`[BinaryService] ${entry.name} response without pending request`, {
+                id: response.id,
+                status: response.status,
+            });
+            return;
+        }
+        logger_1.loggers.bootstrap.debug(`[BinaryService] Received response`, {
+            service: entry.name,
+            id: response.id,
+            status: response.status,
+        });
+        entry.pending.delete(response.id);
+        if (pending.timeout)
+            clearTimeout(pending.timeout);
+        if (response.status === 'ok') {
+            logger_1.loggers.bootstrap.debug(`[BinaryService] Call success`, {
+                service: entry.name,
+                id: response.id,
+            });
+            pending.resolve(response.result);
+            return;
+        }
+        const message = response.error instanceof Error
+            ? response.error.message
+            : typeof response.error === 'string'
+                ? response.error
+                : 'Binary call failed';
+        logger_1.loggers.bootstrap.error(`[BinaryService] Call error response`, {
+            service: entry.name,
+            id: response.id,
+            error: response.error,
+            message,
+        });
+        pending.reject(new app_error_1.AppError('COMMON:UNKNOWN', message, 'external', response.error));
+    }
+    failPending(entry, reason) {
+        for (const [id, pending] of entry.pending) {
+            if (pending.timeout)
+                clearTimeout(pending.timeout);
+            pending.reject(new app_error_1.AppError('COMMON:UNKNOWN', reason, 'external'));
+            entry.pending.delete(id);
+        }
+    }
+    async writeLine(entry, payload) {
+        var _a;
+        const stdin = (_a = entry.process) === null || _a === void 0 ? void 0 : _a.stdin;
+        if (!stdin)
+            return;
+        const line = `${payload}\n`;
+        if (!stdin.write(line)) {
+            await (0, node_events_1.once)(stdin, 'drain');
+        }
+    }
+};
+exports.BinaryProcessManager = BinaryProcessManager;
+exports.BinaryProcessManager = BinaryProcessManager = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(IResourceInfo_1.IResourceInfo)),
+    __metadata("design:paramtypes", [IResourceInfo_1.IResourceInfo])
+], BinaryProcessManager);

package/dist/runtime/server/services/binary/binary.types.d.ts

@@ -0,0 +1,6 @@
+export interface BinaryCallMetadata {
+    methodName: string;
+    action: string;
+    timeoutMs?: number;
+    service?: string;
+}

package/dist/runtime/server/services/binary/binary.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/runtime/server/services/services.register.js

@@ -4,6 +4,7 @@ exports.registerServicesServer = registerServicesServer;
 const index_1 = require("../../../kernel/di/index");
 const world_1 = require("../../core/world");
 const principal_provider_contract_1 = require("../contracts/security/principal-provider.contract");
+const binary_process_manager_1 = require("./binary/binary-process.manager");
 const chat_service_1 = require("./chat.service");
 const command_service_1 = require("./core/command.service");
 const player_service_1 = require("./core/player.service");
@@ -85,4 +86,7 @@ function registerServicesServer(ctx) {
     if (features.chat.enabled) {
         index_1.GLOBAL_CONTAINER.registerSingleton(chat_service_1.ChatService);
     }
+    if (!index_1.GLOBAL_CONTAINER.isRegistered(binary_process_manager_1.BinaryProcessManager)) {
+        index_1.GLOBAL_CONTAINER.registerSingleton(binary_process_manager_1.BinaryProcessManager);
+    }
 }

package/dist/runtime/server/system/metadata-server.keys.d.ts

@@ -9,4 +9,7 @@ export declare const METADATA_KEYS: {
     PUBLIC: string;
     THROTTLE: string;
     REQUIRES_STATE: string;
+    BINARY_SERVICE: string;
+    BINARY_SERVICE_NAME: string;
+    BINARY_CALL: string;
 };

package/dist/runtime/server/system/metadata-server.keys.js

@@ -12,4 +12,7 @@ exports.METADATA_KEYS = {
     PUBLIC: 'decorator:meta:public',
     THROTTLE: 'decorator:throttle',
     REQUIRES_STATE: 'decorator:requires_state',
+    BINARY_SERVICE: 'decorator:meta:binary_service',
+    BINARY_SERVICE_NAME: 'decorator:meta:binary_service_name',
+    BINARY_CALL: 'decorator:meta:binary_call',
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-core/framework",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "Secure, Event-Driven, OOP Engine for FiveM. Stop scripting, start engineering.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -68,12 +68,14 @@
   "author": "OpenCore Team",
   "license": "MPL-2.0",
   "packageManager": "pnpm@10.13.1",
-  "dependencies": {
+  "peerDependencies": {
     "reflect-metadata": "^0.2.2",
     "tsyringe": "^4.10.0",
-    "uuid": "^13.0.0",
     "zod": "^4.3.5"
   },
+  "dependencies": {
+    "uuid": "^13.0.0"
+  },
   "devDependencies": {
     "@biomejs/biome": "^2.3.11",
     "@citizenfx/client": "2.0.22443-1",