@dartfx/n8n-nodes-qsv 0.26.0 → 0.27.0-staging.0

package/dist/nodes/Qsv/Qsv.node.js

@@ -156,7 +156,7 @@ class Qsv {
         group: ['transform'],
         version: 1,
         subtitle: '={{$parameter["operation"]}}',
-        description: 'Ultra-fast tabular data wrangling, stats, and transformations via QSV (generated for QSV 26.0.0; requires qsv CLI on host)',
+        description: 'Ultra-fast tabular data wrangling, stats, and transformations via QSV (generated for QSV 27.0.1; requires qsv CLI on host)',
         defaults: {
             name: 'QSV',
         },

package/dist/nodes/Qsv/actions/executeClean.d.ts

@@ -0,0 +1,2 @@
+import type { IExecuteFunctions, INodeExecutionData } from "n8n-workflow";
+export declare function executeClean(this: IExecuteFunctions, itemIndex: number): Promise<INodeExecutionData[]>;

package/dist/nodes/Qsv/actions/executeClean.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeClean = executeClean;
+const n8n_workflow_1 = require("n8n-workflow");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+async function executeClean(itemIndex) {
+    const inputPath = this.getNodeParameter("inputPath", itemIndex);
+    if (!inputPath || !inputPath.trim()) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Input CSV file path is required.", { itemIndex });
+    }
+    const outputPath = this.getNodeParameter("outputPath", itemIndex, "") || "";
+    const additionalArgs = this.getNodeParameter("additionalArgs", itemIndex, "") || "";
+    const options = this.getNodeParameter("options", itemIndex, {}) || {};
+    const args = ["clean"];
+    if (options.stale === true) {
+        args.push("--stale");
+    }
+    if (options.recursive === true) {
+        args.push("--recursive");
+    }
+    if (options.dryRun === true) {
+        args.push("--dry-run");
+    }
+    if (options.force === true) {
+        args.push("--force");
+    }
+    if (options.index === true) {
+        args.push("--index");
+    }
+    if (options.stats === true) {
+        args.push("--stats");
+    }
+    if (options.frequency === true) {
+        args.push("--frequency");
+    }
+    if (options.schema === true) {
+        args.push("--schema");
+    }
+    if (options.validate === true) {
+        args.push("--validate");
+    }
+    if (options.moarstats === true) {
+        args.push("--moarstats");
+    }
+    if (options.all === true) {
+        args.push("--all");
+    }
+    if (options.quiet === true) {
+        args.push("--quiet");
+    }
+    if (additionalArgs.trim()) {
+        const rawMatches = additionalArgs.match(/[^\s"']+|"[^"]*"|'[^']*'/g) || [];
+        const parsedArgs = rawMatches.map((arg) => {
+            if ((arg.startsWith('"') && arg.endsWith('"')) ||
+                (arg.startsWith("'") && arg.endsWith("'"))) {
+                return arg.slice(1, -1);
+            }
+            return arg;
+        });
+        args.push(...parsedArgs);
+    }
+    if (outputPath.trim()) {
+        args.push("--output", outputPath.trim());
+    }
+    args.push(inputPath);
+    const qsvBin = process.env.DARTFX_QSV_BIN_PATH ||
+        process.env.QSV_BIN_PATH ||
+        process.env.QSV_PATH ||
+        "qsv";
+    try {
+        const { stdout, stderr } = await execFileAsync(qsvBin, args, {
+            maxBuffer: 50 * 1024 * 1024,
+            encoding: "utf8",
+        });
+        let resultJson;
+        try {
+            resultJson = JSON.parse(stdout);
+        }
+        catch {
+            resultJson = {
+                command: "qsv clean",
+                inputPath,
+                rawOutput: stdout,
+            };
+        }
+        const returnJson = {
+            success: true,
+            command: "clean",
+            inputPath,
+            result: resultJson,
+        };
+        if (outputPath.trim()) {
+            returnJson.outputPath = outputPath.trim();
+        }
+        if (stderr && stderr.trim()) {
+            returnJson.warnings = stderr.trim();
+        }
+        return [
+            {
+                json: returnJson,
+            },
+        ];
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The QSV CLI binary ('${qsvBin}') was not found`, {
+                itemIndex,
+                description: `Please ensure 'qsv' is installed and available in the system PATH where n8n is running, or specify its absolute path via the DARTFX_QSV_BIN_PATH environment variable. (https://github.com/dathere/qsv)`,
+            });
+        }
+        if (error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" ||
+            (error.message && error.message.includes("maxBuffer"))) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `QSV execution exceeded maximum stdout buffer (50 MB)`, {
+                itemIndex,
+                description: `qsv clean returned more data than could fit into memory. Specify an 'Output File Path' to stream results directly to disk instead.`,
+            });
+        }
+        const rawError = (error.stderr || error.message || "").trim();
+        if (rawError.includes("is not a qsv command") ||
+            rawError.includes("unrecognized subcommand") ||
+            rawError.includes("not available in this")) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Operation 'clean' is not available in the installed QSV binary`, {
+                itemIndex,
+                description: `The installed QSV binary at '${qsvBin}' does not include the 'clean' feature. This feature may require a full feature build of QSV (e.g. qsv with all_features or a prebuilt binary with feature flags enabled). See https://github.com/dathere/qsv#feature-flags`,
+            });
+        }
+        if (rawError.includes("No such file or directory") ||
+            rawError.includes("os error 2")) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Input file not found: '${inputPath}'`, {
+                itemIndex,
+                description: `qsv clean could not find the file at '${inputPath}'. Check for typos, or if n8n is running in Docker, ensure the host directory is mounted into the container.`,
+            });
+        }
+        if (rawError.includes("Operation not permitted") ||
+            rawError.includes("os error 1") ||
+            rawError.includes("Permission denied") ||
+            rawError.includes("os error 13")) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Permission denied accessing file: '${inputPath}'`, {
+                itemIndex,
+                description: `qsv clean was denied read access to '${inputPath}'. On macOS, check Full Disk Access or Removable Volumes permissions for the application running n8n.`,
+            });
+        }
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed executing 'qsv clean': ${rawError}`, { itemIndex });
+    }
+}

package/dist/nodes/Qsv/actions/executeClipboard.d.ts

@@ -0,0 +1,2 @@
+import type { IExecuteFunctions, INodeExecutionData } from "n8n-workflow";
+export declare function executeClipboard(this: IExecuteFunctions, itemIndex: number): Promise<INodeExecutionData[]>;

package/dist/nodes/Qsv/actions/executeClipboard.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeClipboard = executeClipboard;
+const n8n_workflow_1 = require("n8n-workflow");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+async function executeClipboard(itemIndex) {
+    const inputPath = this.getNodeParameter("inputPath", itemIndex);
+    if (!inputPath || !inputPath.trim()) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Input CSV file path is required.", { itemIndex });
+    }
+    const outputPath = this.getNodeParameter("outputPath", itemIndex, "") || "";
+    const additionalArgs = this.getNodeParameter("additionalArgs", itemIndex, "") || "";
+    const options = this.getNodeParameter("options", itemIndex, {}) || {};
+    const args = ["clipboard"];
+    if (options.save === true) {
+        args.push("--save");
+    }
+    if (additionalArgs.trim()) {
+        const rawMatches = additionalArgs.match(/[^\s"']+|"[^"]*"|'[^']*'/g) || [];
+        const parsedArgs = rawMatches.map((arg) => {
+            if ((arg.startsWith('"') && arg.endsWith('"')) ||
+                (arg.startsWith("'") && arg.endsWith("'"))) {
+                return arg.slice(1, -1);
+            }
+            return arg;
+        });
+        args.push(...parsedArgs);
+    }
+    if (outputPath.trim()) {
+        args.push("--output", outputPath.trim());
+    }
+    args.push(inputPath);
+    const qsvBin = process.env.DARTFX_QSV_BIN_PATH ||
+        process.env.QSV_BIN_PATH ||
+        process.env.QSV_PATH ||
+        "qsv";
+    try {
+        const { stdout, stderr } = await execFileAsync(qsvBin, args, {
+            maxBuffer: 50 * 1024 * 1024,
+            encoding: "utf8",
+        });
+        let resultJson;
+        try {
+            resultJson = JSON.parse(stdout);
+        }
+        catch {
+            resultJson = {
+                command: "qsv clipboard",
+                inputPath,
+                rawOutput: stdout,
+            };
+        }
+        const returnJson = {
+            success: true,
+            command: "clipboard",
+            inputPath,
+            result: resultJson,
+        };
+        if (outputPath.trim()) {
+            returnJson.outputPath = outputPath.trim();
+        }
+        if (stderr && stderr.trim()) {
+            returnJson.warnings = stderr.trim();
+        }
+        return [
+            {
+                json: returnJson,
+            },
+        ];
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The QSV CLI binary ('${qsvBin}') was not found`, {
+                itemIndex,
+                description: `Please ensure 'qsv' is installed and available in the system PATH where n8n is running, or specify its absolute path via the DARTFX_QSV_BIN_PATH environment variable. (https://github.com/dathere/qsv)`,
+            });
+        }
+        if (error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" ||
+            (error.message && error.message.includes("maxBuffer"))) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `QSV execution exceeded maximum stdout buffer (50 MB)`, {
+                itemIndex,
+                description: `qsv clipboard returned more data than could fit into memory. Specify an 'Output File Path' to stream results directly to disk instead.`,
+            });
+        }
+        const rawError = (error.stderr || error.message || "").trim();
+        if (rawError.includes("is not a qsv command") ||
+            rawError.includes("unrecognized subcommand") ||
+            rawError.includes("not available in this")) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Operation 'clipboard' is not available in the installed QSV binary`, {
+                itemIndex,
+                description: `The installed QSV binary at '${qsvBin}' does not include the 'clipboard' feature. This feature may require a full feature build of QSV (e.g. qsv with all_features or a prebuilt binary with feature flags enabled). See https://github.com/dathere/qsv#feature-flags`,
+            });
+        }
+        if (rawError.includes("No such file or directory") ||
+            rawError.includes("os error 2")) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Input file not found: '${inputPath}'`, {
+                itemIndex,
+                description: `qsv clipboard could not find the file at '${inputPath}'. Check for typos, or if n8n is running in Docker, ensure the host directory is mounted into the container.`,
+            });
+        }
+        if (rawError.includes("Operation not permitted") ||
+            rawError.includes("os error 1") ||
+            rawError.includes("Permission denied") ||
+            rawError.includes("os error 13")) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Permission denied accessing file: '${inputPath}'`, {
+                itemIndex,
+                description: `qsv clipboard was denied read access to '${inputPath}'. On macOS, check Full Disk Access or Removable Volumes permissions for the application running n8n.`,
+            });
+        }
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed executing 'qsv clipboard': ${rawError}`, { itemIndex });
+    }
+}

package/dist/nodes/Qsv/actions/executeColor.d.ts

@@ -0,0 +1,2 @@
+import type { IExecuteFunctions, INodeExecutionData } from "n8n-workflow";
+export declare function executeColor(this: IExecuteFunctions, itemIndex: number): Promise<INodeExecutionData[]>;

package/dist/nodes/Qsv/actions/executeColor.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeColor = executeColor;
+const n8n_workflow_1 = require("n8n-workflow");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+async function executeColor(itemIndex) {
+    const inputPath = this.getNodeParameter("inputPath", itemIndex);
+    if (!inputPath || !inputPath.trim()) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Input CSV file path is required.", { itemIndex });
+    }
+    const outputPath = this.getNodeParameter("outputPath", itemIndex, "") || "";
+    const additionalArgs = this.getNodeParameter("additionalArgs", itemIndex, "") || "";
+    const options = this.getNodeParameter("options", itemIndex, {}) || {};
+    const args = ["color"];
+    if (options.color === true) {
+        args.push("--color");
+    }
+    if (options.rowNumbers === true) {
+        args.push("--row-numbers");
+    }
+    if (options.title !== undefined && options.title !== "") {
+        args.push("--title", String(options.title));
+    }
+    if (options.delimiter !== undefined && options.delimiter !== "") {
+        args.push("--delimiter", String(options.delimiter));
+    }
+    if (options.memcheck === true) {
+        args.push("--memcheck");
+    }
+    if (additionalArgs.trim()) {
+        const rawMatches = additionalArgs.match(/[^\s"']+|"[^"]*"|'[^']*'/g) || [];
+        const parsedArgs = rawMatches.map((arg) => {
+            if ((arg.startsWith('"') && arg.endsWith('"')) ||
+                (arg.startsWith("'") && arg.endsWith("'"))) {
+                return arg.slice(1, -1);
+            }
+            return arg;
+        });
+        args.push(...parsedArgs);
+    }
+    if (outputPath.trim()) {
+        args.push("--output", outputPath.trim());
+    }
+    args.push(inputPath);
+    const qsvBin = process.env.DARTFX_QSV_BIN_PATH ||
+        process.env.QSV_BIN_PATH ||
+        process.env.QSV_PATH ||
+        "qsv";
+    try {
+        const { stdout, stderr } = await execFileAsync(qsvBin, args, {
+            maxBuffer: 50 * 1024 * 1024,
+            encoding: "utf8",
+        });
+        let resultJson;
+        try {
+            resultJson = JSON.parse(stdout);
+        }
+        catch {
+            resultJson = {
+                command: "qsv color",
+                inputPath,
+                rawOutput: stdout,
+            };
+        }
+        const returnJson = {
+            success: true,
+            command: "color",
+            inputPath,
+            result: resultJson,
+        };
+        if (outputPath.trim()) {
+            returnJson.outputPath = outputPath.trim();
+        }
+        if (stderr && stderr.trim()) {
+            returnJson.warnings = stderr.trim();
+        }
+        return [
+            {
+                json: returnJson,
+            },
+        ];
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The QSV CLI binary ('${qsvBin}') was not found`, {
+                itemIndex,
+                description: `Please ensure 'qsv' is installed and available in the system PATH where n8n is running, or specify its absolute path via the DARTFX_QSV_BIN_PATH environment variable. (https://github.com/dathere/qsv)`,
+            });
+        }
+        if (error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" ||
+            (error.message && error.message.includes("maxBuffer"))) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `QSV execution exceeded maximum stdout buffer (50 MB)`, {
+                itemIndex,
+                description: `qsv color returned more data than could fit into memory. Specify an 'Output File Path' to stream results directly to disk instead.`,
+            });
+        }
+        const rawError = (error.stderr || error.message || "").trim();
+        if (rawError.includes("is not a qsv command") ||
+            rawError.includes("unrecognized subcommand") ||
+            rawError.includes("not available in this")) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Operation 'color' is not available in the installed QSV binary`, {
+                itemIndex,
+                description: `The installed QSV binary at '${qsvBin}' does not include the 'color' feature. This feature may require a full feature build of QSV (e.g. qsv with all_features or a prebuilt binary with feature flags enabled). See https://github.com/dathere/qsv#feature-flags`,
+            });
+        }
+        if (rawError.includes("No such file or directory") ||
+            rawError.includes("os error 2")) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Input file not found: '${inputPath}'`, {
+                itemIndex,
+                description: `qsv color could not find the file at '${inputPath}'. Check for typos, or if n8n is running in Docker, ensure the host directory is mounted into the container.`,
+            });
+        }
+        if (rawError.includes("Operation not permitted") ||
+            rawError.includes("os error 1") ||
+            rawError.includes("Permission denied") ||
+            rawError.includes("os error 13")) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Permission denied accessing file: '${inputPath}'`, {
+                itemIndex,
+                description: `qsv color was denied read access to '${inputPath}'. On macOS, check Full Disk Access or Removable Volumes permissions for the application running n8n.`,
+            });
+        }
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed executing 'qsv color': ${rawError}`, { itemIndex });
+    }
+}

package/dist/nodes/Qsv/actions/executeLens.d.ts

@@ -0,0 +1,2 @@
+import type { IExecuteFunctions, INodeExecutionData } from "n8n-workflow";
+export declare function executeLens(this: IExecuteFunctions, itemIndex: number): Promise<INodeExecutionData[]>;

package/dist/nodes/Qsv/actions/executeLens.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeLens = executeLens;
+const n8n_workflow_1 = require("n8n-workflow");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+async function executeLens(itemIndex) {
+    const inputPath = this.getNodeParameter("inputPath", itemIndex);
+    if (!inputPath || !inputPath.trim()) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Input CSV file path is required.", { itemIndex });
+    }
+    const outputPath = this.getNodeParameter("outputPath", itemIndex, "") || "";
+    const additionalArgs = this.getNodeParameter("additionalArgs", itemIndex, "") || "";
+    const options = this.getNodeParameter("options", itemIndex, {}) || {};
+    const args = ["lens"];
+    if (options.delimiter !== undefined && options.delimiter !== "") {
+        args.push("--delimiter", String(options.delimiter));
+    }
+    if (options.tabSeparated === true) {
+        args.push("--tab-separated");
+    }
+    if (options.noHeaders === true) {
+        args.push("--no-headers");
+    }
+    if (options.columns !== undefined && options.columns !== "") {
+        args.push("--columns", String(options.columns));
+    }
+    if (options.filter !== undefined && options.filter !== "") {
+        args.push("--filter", String(options.filter));
+    }
+    if (options.find !== undefined && options.find !== "") {
+        args.push("--find", String(options.find));
+    }
+    if (options.ignoreCase === true) {
+        args.push("--ignore-case");
+    }
+    if (options.freezeColumns !== undefined && options.freezeColumns !== "") {
+        args.push("--freeze-columns", String(options.freezeColumns));
+    }
+    if (options.monochrome === true) {
+        args.push("--monochrome");
+    }
+    if (options.wrapMode !== undefined && options.wrapMode !== "") {
+        args.push("--wrap-mode", String(options.wrapMode));
+    }
+    if (options.autoReload === true) {
+        args.push("--auto-reload");
+    }
+    if (options.streamingStdin === true) {
+        args.push("--streaming-stdin");
+    }
+    if (options.prompt !== undefined && options.prompt !== "") {
+        args.push("--prompt", String(options.prompt));
+    }
+    if (options.echoColumn !== undefined && options.echoColumn !== "") {
+        args.push("--echo-column", String(options.echoColumn));
+    }
+    if (options.debug === true) {
+        args.push("--debug");
+    }
+    if (additionalArgs.trim()) {
+        const rawMatches = additionalArgs.match(/[^\s"']+|"[^"]*"|'[^']*'/g) || [];
+        const parsedArgs = rawMatches.map((arg) => {
+            if ((arg.startsWith('"') && arg.endsWith('"')) ||
+                (arg.startsWith("'") && arg.endsWith("'"))) {
+                return arg.slice(1, -1);
+            }
+            return arg;
+        });
+        args.push(...parsedArgs);
+    }
+    if (outputPath.trim()) {
+        args.push("--output", outputPath.trim());
+    }
+    args.push(inputPath);
+    const qsvBin = process.env.DARTFX_QSV_BIN_PATH ||
+        process.env.QSV_BIN_PATH ||
+        process.env.QSV_PATH ||
+        "qsv";
+    try {
+        const { stdout, stderr } = await execFileAsync(qsvBin, args, {
+            maxBuffer: 50 * 1024 * 1024,
+            encoding: "utf8",
+        });
+        let resultJson;
+        try {
+            resultJson = JSON.parse(stdout);
+        }
+        catch {
+            resultJson = {
+                command: "qsv lens",
+                inputPath,
+                rawOutput: stdout,
+            };
+        }
+        const returnJson = {
+            success: true,
+            command: "lens",
+            inputPath,
+            result: resultJson,
+        };
+        if (outputPath.trim()) {
+            returnJson.outputPath = outputPath.trim();
+        }
+        if (stderr && stderr.trim()) {
+            returnJson.warnings = stderr.trim();
+        }
+        return [
+            {
+                json: returnJson,
+            },
+        ];
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The QSV CLI binary ('${qsvBin}') was not found`, {
+                itemIndex,
+                description: `Please ensure 'qsv' is installed and available in the system PATH where n8n is running, or specify its absolute path via the DARTFX_QSV_BIN_PATH environment variable. (https://github.com/dathere/qsv)`,
+            });
+        }
+        if (error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" ||
+            (error.message && error.message.includes("maxBuffer"))) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `QSV execution exceeded maximum stdout buffer (50 MB)`, {
+                itemIndex,
+                description: `qsv lens returned more data than could fit into memory. Specify an 'Output File Path' to stream results directly to disk instead.`,
+            });
+        }
+        const rawError = (error.stderr || error.message || "").trim();
+        if (rawError.includes("is not a qsv command") ||
+            rawError.includes("unrecognized subcommand") ||
+            rawError.includes("not available in this")) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Operation 'lens' is not available in the installed QSV binary`, {
+                itemIndex,
+                description: `The installed QSV binary at '${qsvBin}' does not include the 'lens' feature. This feature may require a full feature build of QSV (e.g. qsv with all_features or a prebuilt binary with feature flags enabled). See https://github.com/dathere/qsv#feature-flags`,
+            });
+        }
+        if (rawError.includes("No such file or directory") ||
+            rawError.includes("os error 2")) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Input file not found: '${inputPath}'`, {
+                itemIndex,
+                description: `qsv lens could not find the file at '${inputPath}'. Check for typos, or if n8n is running in Docker, ensure the host directory is mounted into the container.`,
+            });
+        }
+        if (rawError.includes("Operation not permitted") ||
+            rawError.includes("os error 1") ||
+            rawError.includes("Permission denied") ||
+            rawError.includes("os error 13")) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Permission denied accessing file: '${inputPath}'`, {
+                itemIndex,
+                description: `qsv lens was denied read access to '${inputPath}'. On macOS, check Full Disk Access or Removable Volumes permissions for the application running n8n.`,
+            });
+        }
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed executing 'qsv lens': ${rawError}`, { itemIndex });
+    }
+}

package/dist/nodes/Qsv/actions/executeLog.d.ts

@@ -0,0 +1,2 @@
+import type { IExecuteFunctions, INodeExecutionData } from "n8n-workflow";
+export declare function executeLog(this: IExecuteFunctions, itemIndex: number): Promise<INodeExecutionData[]>;