@tehw0lf/n8n-nodes-unix-socket-bridge 1.3.0 → 1.3.2

package/README.md

@@ -212,6 +212,34 @@ Run any custom script or command:
 }
 ```
 
+## Parameter Validation
+
+The server supports comprehensive parameter validation for security and correctness:
+
+### Parameter Types and Styles
+
+| Type | Description | Validation |
+|------|-------------|------------|
+| `string` | Text values | Regex pattern, length limits |
+| `number` | Numeric values | Min/max value validation |
+| `boolean` | True/false | Converted to command flags |
+| `json` | Complex objects | JSON string validation |
+
+| Style | Format | Example |
+|-------|--------|---------|
+| `argument` | Positional argument | `command value` |
+| `flag` | `--name value` | `command --verbose true` |
+| `single_flag` | `--name=value` | `command --player=spotify` |
+
+### Security Features
+
+- **Regex Validation**: String parameters enforce pattern matching
+- **Length Limits**: `max_length` prevents oversized inputs
+- **Type Safety**: Parameters validated before execution
+- **Required Fields**: Missing required parameters are rejected
+
+See the [main repository](https://github.com/tehw0lf/n8n-nodes-unix-socket-bridge) examples for complete parameter configuration.
+
 ## Server Component
 
 This node requires the Unix Socket Bridge server to be running. The server:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tehw0lf/n8n-nodes-unix-socket-bridge",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "Generic Unix domain socket communication with configurable server support for n8n",
   "main": "index.js",
   "scripts": {

package/dist/nodes/UnixSocketBridge/UnixSocketBridge.node.d.ts

@@ -1,73 +0,0 @@
-import { IExecuteFunctions, ILoadOptionsFunctions, INodeExecutionData, INodePropertyOptions, INodeType, INodeTypeDescription } from "n8n-workflow";
-/**
- * Unix Socket Bridge Node for n8n
- *
- * This node provides a generic interface for communicating with Unix domain socket servers.
- * It supports auto-discovery of available commands, parameter validation, and multiple
- * response formats. Security: All authentication tokens are hashed using SHA-256 before transmission.
- *
- * @example
- * // Basic usage with auto-discovery
- * const node = new UnixSocketBridge();
- * // Configure socket path: /tmp/socket-bridge/playerctl.sock
- * // Enable auto-discovery to see available commands
- * // Select command from dropdown and execute
- *
- * @example
- * // Manual command execution
- * const node = new UnixSocketBridge();
- * // Set autoDiscover to false
- * // Manually specify command and parameters
- *
- * @since 1.0.0
- */
-export declare class UnixSocketBridge implements INodeType {
-    description: INodeTypeDescription;
-    /**
-     * Methods available on this node for dynamic option loading
-     */
-    methods: {
-        loadOptions: {
-            /**
-             * Discovers available commands from a Unix socket server
-             *
-             * This method connects to the specified socket and sends an introspection
-             * request to discover what commands are available. It provides user-friendly
-             * error messages and fallback options when the server is unavailable.
-             *
-             * @param this - The load options function context from n8n
-             * @returns Promise resolving to an array of command options for the dropdown
-             */
-            getAvailableCommands(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
-        };
-    };
-    /**
-     * Executes the Unix Socket Bridge node
-     *
-     * This method handles the main execution logic, including:
-     * - Parameter validation and processing
-     * - Socket communication
-     * - Response parsing and formatting
-     * - Error handling with optional continuation
-     *
-     * @param this - The execution function context from n8n
-     * @returns Promise resolving to node execution data
-     */
-    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
-}
-/**
- * Helper function for Unix socket communication with improved robustness
- *
- * Establishes a connection to a Unix domain socket, sends a message,
- * and returns the response. Includes timeout handling, chunked reading
- * for large responses, and proper cleanup of socket resources.
- *
- * @param socketPath - Path to the Unix domain socket file
- * @param message - Message to send (typically JSON-formatted command)
- * @param timeoutMs - Connection timeout in milliseconds
- * @param maxResponseSize - Maximum response size in bytes
- * @returns Promise resolving to the server response as a string
- *
- * @throws {Error} When socket connection fails, times out, or response too large
- */
-export declare function sendToUnixSocket(socketPath: string, message: string, timeoutMs: number, maxResponseSize?: number): Promise<string>;

package/dist/nodes/UnixSocketBridge/UnixSocketBridge.node.js

@@ -1,717 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendToUnixSocket = exports.UnixSocketBridge = void 0;
-const n8n_workflow_1 = require("n8n-workflow");
-const net = __importStar(require("net"));
-const crypto = __importStar(require("crypto"));
-/**
- * Securely hash a token using SHA-256
- *
- * @param token - The plain text token to hash
- * @returns SHA-256 hash of the token in hexadecimal format
- */
-function hashToken(token) {
-    return crypto.createHash('sha256').update(token).digest('hex');
-}
-/**
- * Unix Socket Bridge Node for n8n
- *
- * This node provides a generic interface for communicating with Unix domain socket servers.
- * It supports auto-discovery of available commands, parameter validation, and multiple
- * response formats. Security: All authentication tokens are hashed using SHA-256 before transmission.
- *
- * @example
- * // Basic usage with auto-discovery
- * const node = new UnixSocketBridge();
- * // Configure socket path: /tmp/socket-bridge/playerctl.sock
- * // Enable auto-discovery to see available commands
- * // Select command from dropdown and execute
- *
- * @example
- * // Manual command execution
- * const node = new UnixSocketBridge();
- * // Set autoDiscover to false
- * // Manually specify command and parameters
- *
- * @since 1.0.0
- */
-class UnixSocketBridge {
-    constructor() {
-        this.description = {
-            displayName: "Unix Socket Bridge",
-            name: "unixSocketBridge",
-            icon: "fa:plug",
-            group: ["communication"],
-            version: 1,
-            subtitle: '={{$parameter["autoDiscover"] ? $parameter["discoveredCommand"] : $parameter["command"]}} @ {{$parameter["socketPath"]}}',
-            description: "Unix domain socket communication with configurable servers",
-            defaults: {
-                name: "Unix Socket Bridge",
-            },
-            inputs: ["main" /* NodeConnectionType.Main */],
-            outputs: ["main" /* NodeConnectionType.Main */],
-            credentials: [
-                {
-                    name: "httpHeaderAuth",
-                    required: false,
-                },
-            ],
-            properties: [
-                {
-                    displayName: "Socket Path",
-                    name: "socketPath",
-                    type: "string",
-                    default: "/tmp/socket-bridge/service.sock",
-                    placeholder: "/tmp/socket-bridge/service.sock",
-                    description: "Path to the Unix domain socket file",
-                    required: true,
-                },
-                {
-                    displayName: "Auto-Discover Commands",
-                    name: "autoDiscover",
-                    type: "boolean",
-                    default: true,
-                    description: "Automatically discover available commands from the server (recommended)",
-                },
-                {
-                    displayName: "Available Commands",
-                    name: "discoveredCommand",
-                    type: "options",
-                    typeOptions: {
-                        loadOptionsMethod: "getAvailableCommands",
-                        loadOptionsDependsOn: ["socketPath"], // Force reload when socket path changes
-                    },
-                    displayOptions: {
-                        show: {
-                            autoDiscover: [true],
-                        },
-                    },
-                    default: "",
-                    description: "Choose from available commands on the server",
-                    placeholder: "Select a command...",
-                },
-                {
-                    displayName: "Refresh Commands",
-                    name: "refreshCommands",
-                    type: "notice",
-                    displayOptions: {
-                        show: {
-                            autoDiscover: [true],
-                        },
-                    },
-                    default: "",
-                    description: "If commands don't load, try changing the socket path slightly and changing it back, or toggle auto-discovery off/on",
-                },
-                {
-                    displayName: "Manual Command",
-                    name: "command",
-                    type: "string",
-                    displayOptions: {
-                        show: {
-                            autoDiscover: [false],
-                        },
-                    },
-                    default: '={{ $json.command || "status" }}',
-                    description: "Command to send to the server (manual mode)",
-                    placeholder: "status",
-                },
-                {
-                    displayName: "Parameters",
-                    name: "parameters",
-                    type: "fixedCollection",
-                    placeholder: "Add Parameter",
-                    typeOptions: {
-                        multipleValues: true,
-                    },
-                    default: {},
-                    options: [
-                        {
-                            name: "parameter",
-                            displayName: "Parameter",
-                            values: [
-                                {
-                                    displayName: "Name",
-                                    name: "name",
-                                    type: "string",
-                                    default: "",
-                                    description: 'Parameter name (e.g., "player")',
-                                    placeholder: "player",
-                                    required: false,
-                                },
-                                {
-                                    displayName: "Value",
-                                    name: "value",
-                                    type: "string",
-                                    default: "",
-                                    description: 'Parameter value (e.g., "spotify")',
-                                    placeholder: "spotify",
-                                },
-                                {
-                                    displayName: "Type",
-                                    name: "type",
-                                    type: "options",
-                                    options: [
-                                        {
-                                            name: "Auto-Detect",
-                                            value: "auto",
-                                            description: "Automatically detect the type",
-                                        },
-                                        {
-                                            name: "String",
-                                            value: "string",
-                                            description: "Text value",
-                                        },
-                                        {
-                                            name: "Number",
-                                            value: "number",
-                                            description: "Numeric value",
-                                        },
-                                        {
-                                            name: "Boolean",
-                                            value: "boolean",
-                                            description: "True/False value",
-                                        },
-                                        {
-                                            name: "JSON",
-                                            value: "json",
-                                            description: "Complex JSON value",
-                                        },
-                                    ],
-                                    default: "auto",
-                                    description: "Parameter value type",
-                                },
-                            ],
-                        },
-                    ],
-                    description: "Additional parameters to pass with the command",
-                },
-                {
-                    displayName: "Timeout (ms)",
-                    name: "timeout",
-                    type: "number",
-                    default: 5000,
-                    description: "Connection timeout in milliseconds",
-                    typeOptions: {
-                        minValue: 1000,
-                        maxValue: 30000,
-                    },
-                },
-                {
-                    displayName: "Response Format",
-                    name: "responseFormat",
-                    type: "options",
-                    options: [
-                        {
-                            name: "Auto-Detect",
-                            value: "auto",
-                            description: "Automatically detect JSON or return as text",
-                        },
-                        {
-                            name: "JSON",
-                            value: "json",
-                            description: "Parse response as JSON (will error if not valid JSON)",
-                        },
-                        {
-                            name: "Text",
-                            value: "text",
-                            description: "Return response as plain text",
-                        },
-                    ],
-                    default: "auto",
-                    description: "How to interpret the server response",
-                },
-                {
-                    displayName: "Options",
-                    name: "options",
-                    type: "collection",
-                    placeholder: "Add Option",
-                    default: {},
-                    options: [
-                        {
-                            displayName: "Continue On Fail",
-                            name: "continueOnFail",
-                            type: "boolean",
-                            default: false,
-                            description: "Whether to continue workflow execution on error",
-                        },
-                        {
-                            displayName: "Max Response Size",
-                            name: "maxResponseSize",
-                            type: "number",
-                            default: 1048576,
-                            description: "Maximum response size in bytes (default: 1MB)",
-                            typeOptions: {
-                                minValue: 1024,
-                                maxValue: 10485760,
-                            },
-                        },
-                        {
-                            displayName: "Include Metadata",
-                            name: "includeMetadata",
-                            type: "boolean",
-                            default: true,
-                            description: "Include metadata like timestamp and socket path in response",
-                        },
-                    ],
-                },
-            ],
-        };
-        /**
-         * Methods available on this node for dynamic option loading
-         */
-        this.methods = {
-            loadOptions: {
-                /**
-                 * Discovers available commands from a Unix socket server
-                 *
-                 * This method connects to the specified socket and sends an introspection
-                 * request to discover what commands are available. It provides user-friendly
-                 * error messages and fallback options when the server is unavailable.
-                 *
-                 * @param this - The load options function context from n8n
-                 * @returns Promise resolving to an array of command options for the dropdown
-                 */
-                async getAvailableCommands() {
-                    const socketPath = this.getNodeParameter("socketPath");
-                    const timeout = 5000;
-                    // Get authentication token from credentials (secure approach only)
-                    let authToken;
-                    try {
-                        const credentials = await this.getCredentials('httpHeaderAuth');
-                        if (credentials && credentials.value) {
-                            authToken = credentials.value;
-                        }
-                    }
-                    catch (error) {
-                        // Credentials not configured - authentication will be skipped
-                    }
-                    // Provide immediate feedback
-                    if (!socketPath || socketPath.trim() === "") {
-                        return [{ name: "⚠️ Please set a socket path first", value: "" }];
-                    }
-                    try {
-                        const introspectionRequest = {
-                            command: "__introspect__",
-                            request_id: `discovery-${Date.now()}`
-                        };
-                        // Add auth token hash if provided (security: never send plain text tokens)
-                        if (authToken && authToken.trim() !== "") {
-                            introspectionRequest.auth_token_hash = hashToken(authToken.trim());
-                        }
-                        const response = await sendToUnixSocket(socketPath, JSON.stringify(introspectionRequest), timeout);
-                        const serverInfo = JSON.parse(response);
-                        if (serverInfo.success &&
-                            serverInfo.server_info &&
-                            serverInfo.server_info.commands) {
-                            const commands = serverInfo.server_info.commands;
-                            const options = [];
-                            // Add server info as header
-                            options.push({
-                                name: `📡 ${serverInfo.server_info.name} (${Object.keys(commands).length} commands available)`,
-                                value: "__server_info__",
-                            });
-                            // Add separator
-                            options.push({
-                                name: "──────────────────────────",
-                                value: "",
-                            });
-                            // Add commands with better formatting
-                            for (const [commandName, commandInfo] of Object.entries(commands)) {
-                                const description = commandInfo.description || "No description";
-                                const hasParams = commandInfo.parameters &&
-                                    Object.keys(commandInfo.parameters).length > 0;
-                                const paramIndicator = hasParams ? " 🔧" : "";
-                                options.push({
-                                    name: `${commandName}${paramIndicator} - ${description}`,
-                                    value: commandName,
-                                    description: hasParams
-                                        ? "This command accepts parameters"
-                                        : undefined,
-                                });
-                            }
-                            return options;
-                        }
-                        else if (serverInfo.error) {
-                            return [
-                                { name: `❌ Server error: ${serverInfo.error}`, value: "" },
-                                { name: "Check server logs for details", value: "" },
-                            ];
-                        }
-                        else {
-                            return [
-                                { name: "⚠️ Server responded but no commands found", value: "" },
-                                { name: "Check server configuration", value: "" },
-                            ];
-                        }
-                    }
-                    catch (error) {
-                        // More specific error messages
-                        if (error.message.includes("timeout")) {
-                            return [
-                                {
-                                    name: "⏱️ Connection timeout - is the server running?",
-                                    value: "",
-                                },
-                                {
-                                    name: "Try: python3 socket-server.py config.json",
-                                    value: "",
-                                },
-                            ];
-                        }
-                        else if (error.message.includes("ENOENT") ||
-                            error.message.includes("not found")) {
-                            return [
-                                { name: "🔍 Socket file not found", value: "" },
-                                { name: `Path: ${socketPath}`, value: "" },
-                                { name: "Check if server is running", value: "" },
-                            ];
-                        }
-                        else if (error.message.includes("ECONNREFUSED")) {
-                            return [
-                                { name: "🚫 Connection refused", value: "" },
-                                { name: "Server may not be listening on this socket", value: "" },
-                            ];
-                        }
-                        else if (error.message.includes("EACCES")) {
-                            return [
-                                { name: "🔒 Permission denied", value: "" },
-                                { name: "Check socket file permissions", value: "" },
-                            ];
-                        }
-                        else {
-                            const shortError = error.message.substring(0, 50);
-                            return [
-                                {
-                                    name: `❌ Error: ${shortError}${error.message.length > 50 ? "..." : ""}`,
-                                    value: "",
-                                },
-                                { name: "You can still use manual mode", value: "" },
-                            ];
-                        }
-                    }
-                },
-            },
-        };
-    }
-    /**
-     * Executes the Unix Socket Bridge node
-     *
-     * This method handles the main execution logic, including:
-     * - Parameter validation and processing
-     * - Socket communication
-     * - Response parsing and formatting
-     * - Error handling with optional continuation
-     *
-     * @param this - The execution function context from n8n
-     * @returns Promise resolving to node execution data
-     */
-    async execute() {
-        const items = this.getInputData();
-        const returnData = [];
-        for (let i = 0; i < items.length; i++) {
-            try {
-                const socketPath = this.getNodeParameter("socketPath", i);
-                const autoDiscover = this.getNodeParameter("autoDiscover", i);
-                const timeout = this.getNodeParameter("timeout", i);
-                const responseFormat = this.getNodeParameter("responseFormat", i);
-                // Get options
-                const options = this.getNodeParameter("options", i, {});
-                const maxResponseSize = options.maxResponseSize || 1048576;
-                const includeMetadata = options.includeMetadata !== false;
-                let command;
-                if (autoDiscover) {
-                    command = this.getNodeParameter("discoveredCommand", i);
-                    // Validate command selection
-                    if (command === "__server_info__" || command === "" || !command) {
-                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Please select a valid command from the dropdown", {
-                            itemIndex: i,
-                            description: "Use the dropdown to select an available command",
-                        });
-                    }
-                }
-                else {
-                    command = this.getNodeParameter("command", i);
-                    if (!command) {
-                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Command is required", { itemIndex: i });
-                    }
-                }
-                // Get authentication token from credentials (secure approach only)
-                let authToken;
-                try {
-                    const credentials = await this.getCredentials('httpHeaderAuth');
-                    if (credentials && credentials.value) {
-                        authToken = credentials.value;
-                    }
-                }
-                catch (error) {
-                    // Credentials not configured - authentication will be skipped
-                }
-                // Build the request
-                const jsonMessage = {
-                    command,
-                    request_id: `n8n-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
-                };
-                // Add auth token hash if provided (security: never send plain text tokens)
-                if (authToken && authToken.trim() !== "") {
-                    jsonMessage.auth_token_hash = hashToken(authToken.trim());
-                }
-                // Process parameters with type handling
-                const parameters = this.getNodeParameter("parameters", i, {});
-                if (parameters &&
-                    parameters.parameter &&
-                    Array.isArray(parameters.parameter) &&
-                    parameters.parameter.length > 0) {
-                    jsonMessage.parameters = {};
-                    for (const param of parameters.parameter) {
-                        if (param.name && param.value !== undefined && param.value !== "") {
-                            const paramType = param.type || "auto";
-                            let processedValue = param.value;
-                            try {
-                                switch (paramType) {
-                                    case "number":
-                                        processedValue = Number(param.value);
-                                        if (isNaN(processedValue)) {
-                                            throw new Error(`Invalid number: ${param.value}`);
-                                        }
-                                        break;
-                                    case "boolean":
-                                        if (typeof param.value === "string") {
-                                            processedValue = ["true", "yes", "1", "on"].includes(param.value.toLowerCase());
-                                        }
-                                        else {
-                                            processedValue = Boolean(param.value);
-                                        }
-                                        break;
-                                    case "json":
-                                        processedValue = JSON.parse(param.value);
-                                        break;
-                                    case "string":
-                                        processedValue = String(param.value);
-                                        break;
-                                    case "auto":
-                                    default:
-                                        // Try to parse as JSON first
-                                        try {
-                                            processedValue = JSON.parse(param.value);
-                                        }
-                                        catch (_a) {
-                                            // If not JSON, keep as string
-                                            processedValue = param.value;
-                                        }
-                                        break;
-                                }
-                                jsonMessage.parameters[param.name] = processedValue;
-                            }
-                            catch (error) {
-                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to process parameter "${param.name}": ${error.message}`, { itemIndex: i });
-                            }
-                        }
-                    }
-                }
-                const messageToSend = JSON.stringify(jsonMessage);
-                // Send message to Unix socket with size limit
-                const response = await sendToUnixSocket(socketPath, messageToSend, timeout, maxResponseSize);
-                // Parse response based on format setting
-                let parsedResponse;
-                if (responseFormat === "auto") {
-                    try {
-                        parsedResponse = JSON.parse(response);
-                    }
-                    catch (_b) {
-                        parsedResponse = response;
-                    }
-                }
-                else if (responseFormat === "json") {
-                    try {
-                        parsedResponse = JSON.parse(response);
-                    }
-                    catch (error) {
-                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to parse response as JSON: ${error.message}`, {
-                            itemIndex: i,
-                            description: "Server response is not valid JSON. Try using 'Text' response format.",
-                        });
-                    }
-                }
-                else {
-                    parsedResponse = response;
-                }
-                // Build response data
-                let responseData;
-                if (includeMetadata) {
-                    responseData = {
-                        socketPath,
-                        command,
-                        request: jsonMessage,
-                        response: parsedResponse,
-                        success: true,
-                        timestamp: new Date().toISOString(),
-                    };
-                    // Extract structured response fields if available
-                    if (typeof parsedResponse === "object" &&
-                        parsedResponse !== null &&
-                        "success" in parsedResponse) {
-                        const cmdResponse = parsedResponse;
-                        responseData.success = cmdResponse.success;
-                        responseData.output =
-                            cmdResponse.stdout || cmdResponse.output || "";
-                        responseData.error = cmdResponse.error || cmdResponse.stderr || "";
-                        responseData.returncode = cmdResponse.returncode;
-                        // Include parsed output if available
-                        if (cmdResponse.parsed_output) {
-                            responseData.parsedOutput = cmdResponse.parsed_output;
-                        }
-                    }
-                }
-                else {
-                    // Return just the response without metadata
-                    if (typeof parsedResponse === "object" &&
-                        parsedResponse !== null &&
-                        "success" in parsedResponse) {
-                        responseData = parsedResponse;
-                    }
-                    else {
-                        responseData = { response: parsedResponse };
-                    }
-                }
-                returnData.push({
-                    json: responseData,
-                    pairedItem: i,
-                });
-            }
-            catch (error) {
-                if (this.continueOnFail()) {
-                    returnData.push({
-                        json: {
-                            error: error.message,
-                            success: false,
-                            timestamp: new Date().toISOString(),
-                            itemIndex: i,
-                        },
-                        pairedItem: i,
-                    });
-                    continue;
-                }
-                throw error;
-            }
-        }
-        return [returnData];
-    }
-}
-exports.UnixSocketBridge = UnixSocketBridge;
-/**
- * Helper function for Unix socket communication with improved robustness
- *
- * Establishes a connection to a Unix domain socket, sends a message,
- * and returns the response. Includes timeout handling, chunked reading
- * for large responses, and proper cleanup of socket resources.
- *
- * @param socketPath - Path to the Unix domain socket file
- * @param message - Message to send (typically JSON-formatted command)
- * @param timeoutMs - Connection timeout in milliseconds
- * @param maxResponseSize - Maximum response size in bytes
- * @returns Promise resolving to the server response as a string
- *
- * @throws {Error} When socket connection fails, times out, or response too large
- */
-async function sendToUnixSocket(socketPath, message, timeoutMs, maxResponseSize = 1048576) {
-    return new Promise((resolve, reject) => {
-        const socket = new net.Socket();
-        let response = "";
-        let responseBuffer = Buffer.alloc(0);
-        const timeoutHandle = setTimeout(() => {
-            socket.destroy();
-            reject(new Error(`Socket connection timeout after ${timeoutMs}ms`));
-        }, timeoutMs);
-        socket.on("connect", () => {
-            socket.write(message);
-        });
-        socket.on("data", (data) => {
-            // Use buffer concatenation for binary safety
-            responseBuffer = Buffer.concat([responseBuffer, data]);
-            // Check size limit
-            if (responseBuffer.length > maxResponseSize) {
-                socket.destroy();
-                clearTimeout(timeoutHandle);
-                reject(new Error(`Response too large (max ${maxResponseSize} bytes)`));
-            }
-        });
-        socket.on("end", () => {
-            clearTimeout(timeoutHandle);
-            try {
-                response = responseBuffer.toString("utf-8");
-                resolve(response);
-            }
-            catch (error) {
-                reject(new Error(`Failed to decode response: ${error.message}`));
-            }
-        });
-        socket.on("close", (hadError) => {
-            clearTimeout(timeoutHandle);
-            if (!hadError && responseBuffer.length > 0) {
-                try {
-                    response = responseBuffer.toString("utf-8");
-                    resolve(response);
-                }
-                catch (error) {
-                    reject(new Error(`Failed to decode response: ${error.message}`));
-                }
-            }
-            else if (!hadError && response) {
-                resolve(response);
-            }
-            else if (!hadError) {
-                reject(new Error("Socket closed without response"));
-            }
-        });
-        socket.on("error", (error) => {
-            clearTimeout(timeoutHandle);
-            // Provide more helpful error messages
-            let errorMessage = error.message;
-            if (error.message.includes("ENOENT")) {
-                errorMessage = `Socket not found at ${socketPath}`;
-            }
-            else if (error.message.includes("ECONNREFUSED")) {
-                errorMessage = `Connection refused at ${socketPath} - is the server running?`;
-            }
-            else if (error.message.includes("EACCES")) {
-                errorMessage = `Permission denied accessing ${socketPath}`;
-            }
-            else if (error.message.includes("ETIMEDOUT")) {
-                errorMessage = `Connection timed out to ${socketPath}`;
-            }
-            reject(new Error(`Socket error: ${errorMessage}`));
-        });
-        // Connect to socket
-        try {
-            socket.connect(socketPath);
-        }
-        catch (error) {
-            clearTimeout(timeoutHandle);
-            reject(new Error(`Failed to connect: ${error.message}`));
-        }
-    });
-}
-exports.sendToUnixSocket = sendToUnixSocket;