@dartfx/n8n-nodes-qsv 0.2.1 → 0.26.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 24.0.0; requires qsv CLI on host)',
+        description: 'Ultra-fast tabular data wrangling, stats, and transformations via QSV (generated for QSV 26.0.0; requires qsv CLI on host)',
         defaults: {
             name: 'QSV',
         },
@@ -328,7 +328,7 @@ class Qsv {
                     {
                         name: 'Geocode (geocode) [Feature: geocode]',
                         value: 'geocode',
-                        description: 'Geocodes a location against an updatable local copy of the Geonames cities & the Maxmind GeoLite2 databases — with caching and multi-threading, this offline path geocodes up to 360,000 records/sec! Can also geocode online (forward & reverse) via the OpenCage geocoder. (Category: utility | Docs: https://github.com/dathere/qsv/blob/master/docs/help/geocode.md)',
+                        description: 'Geocodes a location against an updatable local copy of the Geonames cities & the Maxmind GeoLite2 databases — with caching and multi-threading, this offline path geocodes up to 360,000 records/sec! Can also geocode online (forward & reverse) via the OpenCage geocoder, geocode New York City addresses, BBLs and BINs via NYC\'s Geoclient API, which also returns NYC attributes such as council districts and census tracts, and geocode US addresses & coordinates via the free US Census Geocoder - single or batch - returning Census state, county, tract, block group & block GEOIDs for Census data enrichment. (Category: utility | Docs: https://github.com/dathere/qsv/blob/master/docs/help/geocode.md)',
                         action: 'Geocode',
                     },
                     {

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/executeCount.js

@@ -26,9 +26,6 @@ async function executeCount(itemIndex) {
     if (options.json === true) {
         args.push('--json');
     }
-    if (options.lowMemory === true) {
-        args.push('--low-memory');
-    }
     if (options.noHeaders === true) {
         args.push('--no-headers');
     }

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

@@ -30,12 +30,18 @@ async function executeGeocode(itemIndex) {
     if (options.batch !== undefined && options.batch !== '') {
         args.push('--batch', String(options.batch));
     }
+    if (options.benchmark !== undefined && options.benchmark !== '') {
+        args.push('--benchmark', String(options.benchmark));
+    }
     if (options.cacheDir !== undefined && options.cacheDir !== '') {
         args.push('--cache-dir', String(options.cacheDir));
     }
     if (options.cacheTtl !== undefined && options.cacheTtl !== '') {
         args.push('--cache-ttl', String(options.cacheTtl));
     }
+    if (options.censusMode !== undefined && options.censusMode !== '') {
+        args.push('--census-mode', String(options.censusMode));
+    }
     if (options.citiesUrl !== undefined && options.citiesUrl !== '') {
         args.push('--cities-url', String(options.citiesUrl));
     }
@@ -45,6 +51,9 @@ async function executeGeocode(itemIndex) {
     if (options.delimiter !== undefined && options.delimiter !== '') {
         args.push('--delimiter', String(options.delimiter));
     }
+    if (options.endpoint !== undefined && options.endpoint !== '') {
+        args.push('--endpoint', String(options.endpoint));
+    }
     if (options.force === true) {
         args.push('--force');
     }
@@ -78,6 +87,9 @@ async function executeGeocode(itemIndex) {
     if (options.olderThan !== undefined && options.olderThan !== '') {
         args.push('--older-than', String(options.olderThan));
     }
+    if (options.params !== undefined && options.params !== '') {
+        args.push('--params', String(options.params));
+    }
     if (options.rateLimit !== undefined && options.rateLimit !== '') {
         args.push('--rate-limit', String(options.rateLimit));
     }
@@ -90,6 +102,9 @@ async function executeGeocode(itemIndex) {
     if (options.timeout !== undefined && options.timeout !== '') {
         args.push('--timeout', String(options.timeout));
     }
+    if (options.vintage !== undefined && options.vintage !== '') {
+        args.push('--vintage', String(options.vintage));
+    }
     if (additionalArgs.trim()) {
         const rawMatches = additionalArgs.match(/[^\s"']+|"[^"]*"|'[^']*'/g) || [];
         const parsedArgs = rawMatches.map((arg) => {

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

@@ -22,6 +22,9 @@ async function executeGeoconvert(itemIndex) {
     const additionalArgs = this.getNodeParameter('additionalArgs', itemIndex, '') || '';
     const options = this.getNodeParameter('options', itemIndex, {}) || {};
     const args = ['geoconvert'];
+    if (options.delimiter !== undefined && options.delimiter !== '') {
+        args.push('--delimiter', String(options.delimiter));
+    }
     if (options.geometry !== undefined && options.geometry !== '') {
         args.push('--geometry', String(options.geometry));
     }

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

@@ -83,9 +83,6 @@ async function executeJoinp(itemIndex) {
     if (options.left_by !== undefined && options.left_by !== '') {
         args.push('--left_by', String(options.left_by));
     }
-    if (options.lowMemory === true) {
-        args.push('--low-memory');
-    }
     if (options.maintainOrder !== undefined && options.maintainOrder !== '') {
         args.push('--maintain-order', String(options.maintainOrder));
     }

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[]>;