n8n-nodes-pictomancer 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pictomancer.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,48 @@
+# n8n-nodes-pictomancer
+
+[n8n](https://n8n.io) community node for [Pictomancer.ai](https://pictomancer.ai) - image optimization in your workflows: resize, compress, convert (JPEG/PNG/WebP/TIFF/GIF/AVIF), crop, and multi-step pipelines.
+
+## Install
+
+In n8n: **Settings → Community Nodes → Install** and enter `n8n-nodes-pictomancer`.
+
+Or with npm (self-hosted):
+
+```bash
+npm install n8n-nodes-pictomancer
+```
+
+## Credentials
+
+Create a **Pictomancer API** credential:
+
+- **API Key** - Bearer token from [app.pictomancer.ai](https://app.pictomancer.ai). Optional: without it you are on the free tier (50 requests per IP).
+- **Base URL** - defaults to `https://api.pictomancer.ai`.
+
+## Operations
+
+| Operation | Input | Output |
+|-----------|-------|--------|
+| Analyze | URL or binary | JSON metadata (`size_bytes`) |
+| Resize | URL or binary | Binary image |
+| Compress | URL or binary | Binary image |
+| Convert | URL or binary | Binary image |
+| Crop | URL or binary | Binary image |
+| Pipeline | URL or binary | Binary image |
+
+- **Input Type** switches between a source URL and binary data from the previous node (sent as a `data:` URI).
+- Image operations output binary data (default property `data`) plus `size_bytes`, `mime_type`, and `billed` in the item JSON. `billed` is `false` when compress produced no size gain - those requests are free.
+- **Options** exposes quality (`q`), output format, metadata strip, lossless, and the AVIF `effort` knob.
+- **Pipeline** takes a JSON list of steps, e.g. `[{ "type": "resize", "params": { "scale": "0.5" } }, { "type": "convert", "params": { "format": "webp" } }]`.
+
+## Development
+
+```bash
+npm install
+npm test
+npm run build
+```
+
+## License
+
+MIT

package/dist/credentials/PictomancerApi.credentials.d.ts

@@ -0,0 +1,9 @@
+import type { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INodeProperties } from "n8n-workflow";
+export declare class PictomancerApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+    test: ICredentialTestRequest;
+}

package/dist/credentials/PictomancerApi.credentials.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PictomancerApi = void 0;
+class PictomancerApi {
+    name = "pictomancerApi";
+    displayName = "Pictomancer API";
+    documentationUrl = "https://pictomancer.ai";
+    properties = [
+        {
+            displayName: "API Key",
+            name: "apiKey",
+            type: "string",
+            typeOptions: { password: true },
+            default: "",
+            description: "Bearer token from app.pictomancer.ai. Leave empty to use the free tier (50 requests per IP).",
+        },
+        {
+            displayName: "Base URL",
+            name: "baseUrl",
+            type: "string",
+            default: "https://api.pictomancer.ai",
+        },
+    ];
+    authenticate = {
+        type: "generic",
+        properties: {
+            headers: {
+                Authorization: '={{$credentials.apiKey ? "Bearer " + $credentials.apiKey : undefined}}',
+            },
+        },
+    };
+    test = {
+        request: {
+            baseURL: "={{$credentials.baseUrl}}",
+            url: "/v1/info",
+        },
+    };
+}
+exports.PictomancerApi = PictomancerApi;

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

@@ -0,0 +1,5 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from "n8n-workflow";
+export declare class Pictomancer implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/Pictomancer/Pictomancer.node.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pictomancer = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const operations_1 = require("./operations");
+class Pictomancer {
+    description = {
+        displayName: "Pictomancer",
+        name: "pictomancer",
+        icon: "file:pictomancer.svg",
+        group: ["transform"],
+        version: 1,
+        subtitle: '={{$parameter["operation"]}}',
+        description: "Optimize images with Pictomancer.ai",
+        defaults: { name: "Pictomancer" },
+        inputs: ["main"],
+        outputs: ["main"],
+        credentials: [{ name: "pictomancerApi", required: true }],
+        properties: [
+            {
+                displayName: "Operation",
+                name: "operation",
+                type: "options",
+                noDataExpression: true,
+                default: "compress",
+                options: [
+                    { name: "Analyze", value: "analyze", action: "Analyze an image" },
+                    { name: "Compress", value: "compress", action: "Compress an image" },
+                    { name: "Convert", value: "convert", action: "Convert image format" },
+                    { name: "Crop", value: "crop", action: "Crop an image" },
+                    { name: "Pipeline", value: "pipeline", action: "Run an operation pipeline" },
+                    { name: "Resize", value: "resize", action: "Resize an image" },
+                ],
+            },
+            {
+                displayName: "Input Type",
+                name: "inputType",
+                type: "options",
+                noDataExpression: true,
+                default: "url",
+                options: [
+                    { name: "URL", value: "url" },
+                    { name: "Binary Data", value: "binary" },
+                ],
+            },
+            {
+                displayName: "Source URL",
+                name: "source",
+                type: "string",
+                default: "",
+                required: true,
+                placeholder: "https://example.com/image.jpg",
+                displayOptions: { show: { inputType: ["url"] } },
+            },
+            {
+                displayName: "Input Binary Field",
+                name: "binaryPropertyName",
+                type: "string",
+                default: "data",
+                required: true,
+                displayOptions: { show: { inputType: ["binary"] } },
+            },
+            {
+                displayName: "Scale",
+                name: "scale",
+                type: "number",
+                default: 0.5,
+                description: "Uniform scale factor (e.g. 0.5 = half size)",
+                displayOptions: { show: { operation: ["resize"] } },
+            },
+            {
+                displayName: "Format",
+                name: "format",
+                type: "options",
+                default: "webp",
+                options: [
+                    { name: "AVIF", value: "avif" },
+                    { name: "GIF", value: "gif" },
+                    { name: "JPEG", value: "jpeg" },
+                    { name: "PNG", value: "png" },
+                    { name: "TIFF", value: "tiff" },
+                    { name: "WebP", value: "webp" },
+                ],
+                displayOptions: { show: { operation: ["convert"] } },
+            },
+            {
+                displayName: "X",
+                name: "x",
+                type: "number",
+                default: 0,
+                displayOptions: { show: { operation: ["crop"] } },
+            },
+            {
+                displayName: "Y",
+                name: "y",
+                type: "number",
+                default: 0,
+                displayOptions: { show: { operation: ["crop"] } },
+            },
+            {
+                displayName: "Width",
+                name: "width",
+                type: "number",
+                default: 100,
+                displayOptions: { show: { operation: ["crop"] } },
+            },
+            {
+                displayName: "Height",
+                name: "height",
+                type: "number",
+                default: 100,
+                displayOptions: { show: { operation: ["crop"] } },
+            },
+            {
+                displayName: "Operations (JSON)",
+                name: "pipelineOperations",
+                type: "json",
+                default: '[\n  { "type": "resize", "params": { "scale": "0.5" } },\n  { "type": "convert", "params": { "format": "webp" } }\n]',
+                description: "Ordered list of pipeline steps, each {type, params}",
+                displayOptions: { show: { operation: ["pipeline"] } },
+            },
+            {
+                displayName: "Options",
+                name: "options",
+                type: "collection",
+                placeholder: "Add option",
+                default: {},
+                displayOptions: { show: { operation: ["resize", "compress", "convert"] } },
+                options: [
+                    {
+                        displayName: "Effort (AVIF)",
+                        name: "effort",
+                        type: "number",
+                        typeOptions: { minValue: 0, maxValue: 9 },
+                        default: 2,
+                        description: "AV1 encoder CPU effort (0-9). Higher = smaller files, slower.",
+                    },
+                    {
+                        displayName: "Lossless",
+                        name: "lossless",
+                        type: "boolean",
+                        default: false,
+                        description: "Whether to encode losslessly (WebP and AVIF)",
+                    },
+                    {
+                        displayName: "Output Format",
+                        name: "format",
+                        type: "string",
+                        default: "",
+                        description: "Output format for resize/compress (jpeg, png, webp, tiff, gif, avif)",
+                    },
+                    {
+                        displayName: "Quality",
+                        name: "q",
+                        type: "number",
+                        typeOptions: { minValue: 1, maxValue: 100 },
+                        default: 85,
+                    },
+                    {
+                        displayName: "Scale X",
+                        name: "scale_x",
+                        type: "number",
+                        default: 0,
+                        description: "Horizontal scale factor (overrides Scale together with Scale Y)",
+                    },
+                    {
+                        displayName: "Scale Y",
+                        name: "scale_y",
+                        type: "number",
+                        default: 0,
+                        description: "Vertical scale factor (overrides Scale together with Scale X)",
+                    },
+                    {
+                        displayName: "Strip Metadata",
+                        name: "strip",
+                        type: "boolean",
+                        default: false,
+                    },
+                ],
+            },
+            {
+                displayName: "Output Binary Field",
+                name: "outputBinaryPropertyName",
+                type: "string",
+                default: "data",
+                displayOptions: { show: { operation: ["resize", "compress", "convert", "crop", "pipeline"] } },
+            },
+        ],
+    };
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = await this.getCredentials("pictomancerApi");
+        const baseUrl = String(credentials.baseUrl ?? "https://api.pictomancer.ai").replace(/\/$/, "");
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const operation = this.getNodeParameter("operation", i);
+                const source = await resolveSource(this, i);
+                const params = collectParams(this, operation, i);
+                const { path, body } = (0, operations_1.buildOperationRequest)(operation, source, params);
+                const response = await this.helpers.httpRequestWithAuthentication.call(this, "pictomancerApi", {
+                    method: "POST",
+                    url: `${baseUrl}${path}`,
+                    body,
+                    json: true,
+                    encoding: "arraybuffer",
+                    returnFullResponse: true,
+                });
+                const contentType = String(response.headers["content-type"] ?? "");
+                if (operation === "analyze" || contentType.startsWith("application/json")) {
+                    const text = Buffer.from(response.body).toString("utf-8");
+                    returnData.push({ json: JSON.parse(text), pairedItem: { item: i } });
+                    continue;
+                }
+                const outputProperty = this.getNodeParameter("outputBinaryPropertyName", i);
+                const buffer = Buffer.from(response.body);
+                const binary = await this.helpers.prepareBinaryData(buffer, undefined, contentType);
+                returnData.push({
+                    json: {
+                        size_bytes: buffer.length,
+                        mime_type: contentType,
+                        billed: response.headers["x-pig-billed"] === "1",
+                    },
+                    binary: { [outputProperty]: binary },
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: { error: error.message },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex: i });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.Pictomancer = Pictomancer;
+async function resolveSource(ctx, itemIndex) {
+    const inputType = ctx.getNodeParameter("inputType", itemIndex);
+    if (inputType === "url") {
+        return ctx.getNodeParameter("source", itemIndex);
+    }
+    const propertyName = ctx.getNodeParameter("binaryPropertyName", itemIndex);
+    const binaryData = ctx.helpers.assertBinaryData(itemIndex, propertyName);
+    const buffer = await ctx.helpers.getBinaryDataBuffer(itemIndex, propertyName);
+    return (0, operations_1.toDataUri)(binaryData.mimeType ?? "application/octet-stream", buffer.toString("base64"));
+}
+function collectParams(ctx, operation, itemIndex) {
+    if (operation === "analyze")
+        return {};
+    if (operation === "crop") {
+        return {
+            x: ctx.getNodeParameter("x", itemIndex),
+            y: ctx.getNodeParameter("y", itemIndex),
+            width: ctx.getNodeParameter("width", itemIndex),
+            height: ctx.getNodeParameter("height", itemIndex),
+        };
+    }
+    if (operation === "pipeline") {
+        const raw = ctx.getNodeParameter("pipelineOperations", itemIndex);
+        const operations = typeof raw === "string" ? JSON.parse(raw) : raw;
+        return { operations };
+    }
+    const params = {
+        ...ctx.getNodeParameter("options", itemIndex, {}),
+    };
+    if (operation === "resize") {
+        // scale_x/scale_y in Options take precedence over the plain Scale knob
+        if (!params.scale_x && !params.scale_y) {
+            params.scale = ctx.getNodeParameter("scale", itemIndex);
+        }
+        else {
+            delete params.scale;
+        }
+        if (!params.scale_x)
+            delete params.scale_x;
+        if (!params.scale_y)
+            delete params.scale_y;
+    }
+    if (operation === "convert") {
+        params.format = ctx.getNodeParameter("format", itemIndex);
+    }
+    return params;
+}

package/dist/nodes/Pictomancer/operations.d.ts

@@ -0,0 +1,13 @@
+export interface OperationRequest {
+    path: string;
+    body: Record<string, unknown>;
+}
+export type OperationParams = Record<string, unknown>;
+/**
+ * Map an n8n operation + collected parameters to the API request.
+ * Empty strings and undefined are dropped so optional node fields
+ * never reach the API as explicit values.
+ */
+export declare function buildOperationRequest(operation: string, source: string, params: OperationParams): OperationRequest;
+/** data: URI for binary inputs so any upstream item can be a source. */
+export declare function toDataUri(mimeType: string, base64: string): string;

package/dist/nodes/Pictomancer/operations.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOperationRequest = buildOperationRequest;
+exports.toDataUri = toDataUri;
+const OPERATION_PATHS = {
+    analyze: "/v1/analyze",
+    resize: "/v1/resize",
+    compress: "/v1/compress",
+    convert: "/v1/convert",
+    crop: "/v1/crop",
+    pipeline: "/v1/pipeline",
+};
+/**
+ * Map an n8n operation + collected parameters to the API request.
+ * Empty strings and undefined are dropped so optional node fields
+ * never reach the API as explicit values.
+ */
+function buildOperationRequest(operation, source, params) {
+    const path = OPERATION_PATHS[operation];
+    if (path === undefined) {
+        throw new Error(`unsupported operation: ${operation}`);
+    }
+    const body = { source };
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined || value === "")
+            continue;
+        body[key] = value;
+    }
+    return { path, body };
+}
+/** data: URI for binary inputs so any upstream item can be a source. */
+function toDataUri(mimeType, base64) {
+    return `data:${mimeType};base64,${base64}`;
+}

package/dist/nodes/Pictomancer/pictomancer.svg

@@ -0,0 +1,9 @@
+<svg viewBox="0 0 512 512" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <clipPath id="c">
+      <circle cx="256" cy="256" r="220"/>
+    </clipPath>
+  </defs>
+  <circle cx="256" cy="256" r="220" fill="#a855f7"/>
+  <circle cx="172" cy="155" r="190" fill="white" opacity="0.35" clip-path="url(#c)"/>
+</svg>

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "n8n-nodes-pictomancer",
+  "version": "0.1.0",
+  "description": "n8n community node for Pictomancer.ai - image optimization (resize, compress, convert, crop, pipeline)",
+  "license": "MIT",
+  "homepage": "https://pictomancer.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pictomancer/n8n-nodes-pictomancer.git"
+  },
+  "main": "index.js",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "n8n-community-node-package",
+    "image",
+    "optimization",
+    "resize",
+    "compress",
+    "avif",
+    "webp",
+    "pictomancer"
+  ],
+  "engines": {
+    "node": ">=20.15"
+  },
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/PictomancerApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/Pictomancer/Pictomancer.node.js"
+    ]
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node -e \"require('node:fs').copyFileSync('nodes/Pictomancer/pictomancer.svg','dist/nodes/Pictomancer/pictomancer.svg')\"",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/node": "^18.19.130",
+    "n8n-workflow": "^1.70.0",
+    "typescript": "^5.4.0",
+    "vitest": "^3.0.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  }
+}