@tpsdev-ai/n8n-nodes-flair 0.8.1 → 0.8.2

package/dist/credentials/FlairApi.credentials.js

@@ -55,9 +55,17 @@ class FlairApi {
     ];
     authenticate = {
         type: 'generic',
+        // Use n8n's built-in HTTP Basic auth handling — it base64-encodes
+        // username:password internally. Avoids relying on Buffer being in n8n's
+        // expression sandbox (it isn't always, depending on n8n version).
+        // Earlier the credential used a custom expression with `Buffer.from(...)`
+        // which silently produced an empty Authorization header on installs
+        // where Buffer wasn't whitelisted in the expression engine, causing
+        // "Authorization failed" with valid credentials (2026-05-11 incident).
         properties: {
-            headers: {
-                Authorization: "=Basic {{ Buffer.from('admin:' + $credentials.adminPassword).toString('base64') }}",
+            auth: {
+                username: 'admin',
+                password: '={{ $credentials.adminPassword }}',
             },
         },
     };

package/dist/nodes/FlairChatMemory/FlairChatMemory.node.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlairChatMemory = void 0;
 const memory_1 = require("@langchain/classic/memory");
 const n8n_workflow_1 = require("n8n-workflow");
-const flair_client_1 = require("@tpsdev-ai/flair-client");
 const FlairChatMessageHistory_1 = require("./FlairChatMessageHistory");
 class FlairChatMemory {
     description = {
@@ -70,7 +69,11 @@ class FlairChatMemory {
         const sessionKey = this.getNodeParameter("sessionKey", itemIndex, "");
         const k = this.getNodeParameter("contextWindowLength", itemIndex, 10);
         const composedSubject = sessionKey ? `${subject}:${sessionKey}` : subject;
-        const flair = new flair_client_1.FlairClient({
+        // See FlairWrite.node.ts for the rationale on Function-wrapped dynamic
+        // import (prevents TSC from downleveling to require() under
+        // module: "CommonJS").
+        const flairMod = await new Function("return import('@tpsdev-ai/flair-client')")();
+        const flair = new flairMod.FlairClient({
             url: credentials.baseUrl,
             agentId: credentials.agentId,
             adminUser: "admin",

package/dist/nodes/FlairSearch/FlairSearch.node.js

@@ -4,9 +4,13 @@ exports.FlairSearch = void 0;
 const tools_1 = require("@langchain/core/tools");
 const zod_1 = require("zod");
 const n8n_workflow_1 = require("n8n-workflow");
-const flair_client_1 = require("@tpsdev-ai/flair-client");
-function makeClient(credentials) {
-    return new flair_client_1.FlairClient({
+// See FlairWrite.node.ts for the rationale on Function-wrapped dynamic
+// import (prevents TSC from downleveling to require() under
+// module: "CommonJS").
+const importFlairClient = () => new Function("return import('@tpsdev-ai/flair-client')")();
+async function makeClient(credentials) {
+    const mod = await importFlairClient();
+    return new mod.FlairClient({
         url: credentials.baseUrl,
         agentId: credentials.agentId,
         adminUser: "admin",
@@ -126,7 +130,7 @@ class FlairSearch {
         const credentials = (await this.getCredentials("flairApi"));
         const operation = this.getNodeParameter("operation", itemIndex);
         const limit = this.getNodeParameter("limit", itemIndex, 5);
-        const flair = makeClient(credentials);
+        const flair = await makeClient(credentials);
         if (operation === "search") {
             const tool = new tools_1.DynamicStructuredTool({
                 name: "flair_search",
@@ -159,7 +163,7 @@ class FlairSearch {
     }
     async execute() {
         const credentials = (await this.getCredentials("flairApi"));
-        const flair = makeClient(credentials);
+        const flair = await makeClient(credentials);
         const inputs = this.getInputData();
         const out = [];
         for (let i = 0; i < inputs.length; i++) {

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

@@ -0,0 +1,30 @@
+/**
+ * FlairWrite — pipeline-mode node that writes a memory into Flair.
+ *
+ * Complement to FlairSearch (read-only AI Tool) and FlairChatMemory
+ * (LangChain BaseMemory adapter). FlairWrite is a regular Main-input /
+ * Main-output node intended for capture-and-archive workflows: take an
+ * incoming item (a TPS mail, a webhook payload, a parsed document) and
+ * persist its content as a Flair memory with operator-chosen tags,
+ * subject, and durability.
+ *
+ * Why a separate node from FlairSearch:
+ *   - FlairSearch is wired into the AI Tool socket; it's read-only by
+ *     design (write-as-LLM-tool needs guardrails we haven't designed
+ *     yet — content sanitization, rate limiting, audit trail).
+ *   - FlairWrite is operator-driven. Side effects are intentional and
+ *     scoped to the workflow author's choices, not the LLM's.
+ *   - Splitting keeps the AI-Tool-only contract on FlairSearch clean
+ *     and lets each node evolve independently.
+ *
+ * The dual-purpose alternative (one node with both AI Tool and Main
+ * sockets) is possible in n8n but harder to reason about — the same
+ * configuration would surface differently depending on which socket
+ * the user wires it to. Two narrow nodes are easier to discover and
+ * easier to dogfood.
+ */
+import { type IExecuteFunctions, type INodeExecutionData, type INodeType, type INodeTypeDescription } from "n8n-workflow";
+export declare class FlairWrite implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/FlairWrite/FlairWrite.node.js

@@ -0,0 +1,192 @@
+"use strict";
+/**
+ * FlairWrite — pipeline-mode node that writes a memory into Flair.
+ *
+ * Complement to FlairSearch (read-only AI Tool) and FlairChatMemory
+ * (LangChain BaseMemory adapter). FlairWrite is a regular Main-input /
+ * Main-output node intended for capture-and-archive workflows: take an
+ * incoming item (a TPS mail, a webhook payload, a parsed document) and
+ * persist its content as a Flair memory with operator-chosen tags,
+ * subject, and durability.
+ *
+ * Why a separate node from FlairSearch:
+ *   - FlairSearch is wired into the AI Tool socket; it's read-only by
+ *     design (write-as-LLM-tool needs guardrails we haven't designed
+ *     yet — content sanitization, rate limiting, audit trail).
+ *   - FlairWrite is operator-driven. Side effects are intentional and
+ *     scoped to the workflow author's choices, not the LLM's.
+ *   - Splitting keeps the AI-Tool-only contract on FlairSearch clean
+ *     and lets each node evolve independently.
+ *
+ * The dual-purpose alternative (one node with both AI Tool and Main
+ * sockets) is possible in n8n but harder to reason about — the same
+ * configuration would surface differently depending on which socket
+ * the user wires it to. Two narrow nodes are easier to discover and
+ * easier to dogfood.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlairWrite = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+// Wrap dynamic import in Function() so TypeScript (compiled to CommonJS
+// for n8n consumption) doesn't downlevel `await import(...)` to a `require()`
+// call. The downleveled require() hits flair-client's ESM-only exports map
+// and Node 24+ rejects it (which is what bit us in n8n at runtime —
+// commit 31dd2b3 "fixed" this via dynamic import but TSC compiled it right
+// back to require under `module: "CommonJS"`).
+// The Function() trick keeps the import as a true native dynamic import in
+// the emitted JS, which Node honors as ESM regardless of caller's module
+// type. Standard CJS-to-ESM interop pattern.
+const importFlairClient = () => new Function("return import('@tpsdev-ai/flair-client')")();
+async function makeClient(credentials) {
+    const mod = await importFlairClient();
+    return new mod.FlairClient({
+        url: credentials.baseUrl,
+        agentId: credentials.agentId,
+        adminUser: "admin",
+        adminPassword: credentials.adminPassword,
+    });
+}
+class FlairWrite {
+    description = {
+        displayName: "Flair Write",
+        name: "flairWrite",
+        icon: "file:flair.svg",
+        group: ["output"],
+        version: [1],
+        description: "Write a memory into Flair from a workflow item. Use for capture-and-archive flows (mail → memory, webhook → memory, parsed-doc → memory).",
+        defaults: {
+            name: "Flair Write",
+        },
+        credentials: [
+            {
+                name: "flairApi",
+                required: true,
+            },
+        ],
+        codex: {
+            categories: ["AI"],
+            subcategories: {
+                AI: ["Memory"],
+            },
+            resources: {
+                primaryDocumentation: [
+                    {
+                        url: "https://github.com/tpsdev-ai/flair#n8n",
+                    },
+                ],
+            },
+        },
+        inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+        outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+        properties: [
+            {
+                displayName: "Content",
+                name: "content",
+                type: "string",
+                typeOptions: { rows: 4 },
+                default: "={{ $json.content }}",
+                required: true,
+                description: "The memory content to store. Defaults to the input item's `content` field; override with any expression that produces a string.",
+            },
+            {
+                displayName: "Subject",
+                name: "subject",
+                type: "string",
+                default: "",
+                description: "Optional subject (the entity / conversation / topic this memory is about). Maps to Flair's `subject` field. Leave blank to omit.",
+            },
+            {
+                displayName: "Tags",
+                name: "tags",
+                type: "string",
+                default: "",
+                description: 'Comma-separated tags (e.g. "source:tps-mail, kind:review, agent:kern"). Whitespace around commas is trimmed.',
+            },
+            {
+                displayName: "Durability",
+                name: "durability",
+                type: "options",
+                options: [
+                    { name: "Standard (default)", value: "standard" },
+                    { name: "Persistent (key decisions)", value: "persistent" },
+                    { name: "Permanent (inviolable)", value: "permanent" },
+                    { name: "Ephemeral (auto-expires 72h)", value: "ephemeral" },
+                ],
+                default: "standard",
+                description: "Durability tier. See Flair docs for the semantic differences.",
+            },
+            {
+                displayName: "Type",
+                name: "type",
+                type: "options",
+                options: [
+                    { name: "Session (default)", value: "session" },
+                    { name: "Lesson", value: "lesson" },
+                    { name: "Decision", value: "decision" },
+                    { name: "Preference", value: "preference" },
+                    { name: "Fact", value: "fact" },
+                    { name: "Goal", value: "goal" },
+                ],
+                default: "session",
+                description: "Memory type. Used by Flair's downstream filters and ranking.",
+            },
+            {
+                displayName: "Skip Empty Content",
+                name: "skipEmpty",
+                type: "boolean",
+                default: true,
+                description: "If on, items whose content evaluates to an empty/whitespace-only string are passed through without writing. Off = the node throws on empty content (fail-loud for required-field workflows).",
+            },
+        ],
+    };
+    async execute() {
+        const credentials = (await this.getCredentials("flairApi"));
+        const flair = await makeClient(credentials);
+        const inputs = this.getInputData();
+        const out = [];
+        for (let i = 0; i < inputs.length; i++) {
+            const content = this.getNodeParameter("content", i);
+            const subject = this.getNodeParameter("subject", i, "");
+            const tagsStr = this.getNodeParameter("tags", i, "");
+            const durability = this.getNodeParameter("durability", i, "standard");
+            const type = this.getNodeParameter("type", i, "session");
+            const skipEmpty = this.getNodeParameter("skipEmpty", i, true);
+            const trimmedContent = (content ?? "").trim();
+            if (trimmedContent === "") {
+                if (skipEmpty) {
+                    // Pass-through: surface that we skipped, but don't error.
+                    out.push({
+                        json: { ...inputs[i].json, _flair_skipped: "empty content" },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw new Error(`FlairWrite: empty content on item ${i} (skipEmpty is off). ` +
+                    `Content evaluated to "${content ?? ""}".`);
+            }
+            const tags = tagsStr
+                .split(",")
+                .map((t) => t.trim())
+                .filter((t) => t.length > 0);
+            const result = await flair.memory.write(trimmedContent, {
+                type,
+                durability,
+                tags: tags.length > 0 ? tags : undefined,
+                subject: subject || undefined,
+            });
+            out.push({
+                json: {
+                    ...inputs[i].json,
+                    _flair_id: result.id,
+                    _flair_subject: subject || null,
+                    _flair_tags: tags,
+                    _flair_durability: durability,
+                    _flair_type: type,
+                },
+                pairedItem: { item: i },
+            });
+        }
+        return [out];
+    }
+}
+exports.FlairWrite = FlairWrite;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tpsdev-ai/n8n-nodes-flair",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "n8n community node — use Flair as your AI Agent's memory backend. Includes FlairChatMemory (Memory port) and FlairSearch (Tool port).",
   "type": "commonjs",
   "main": "dist/index.js",
@@ -24,7 +24,8 @@
     ],
     "nodes": [
       "dist/nodes/FlairChatMemory/FlairChatMemory.node.js",
-      "dist/nodes/FlairSearch/FlairSearch.node.js"
+      "dist/nodes/FlairSearch/FlairSearch.node.js",
+      "dist/nodes/FlairWrite/FlairWrite.node.js"
     ]
   },
   "engines": {
@@ -47,7 +48,7 @@
     "langchain"
   ],
   "dependencies": {
-    "@tpsdev-ai/flair-client": "0.8.1",
+    "@tpsdev-ai/flair-client": "0.8.2",
     "zod": "3.25.76"
   },
   "peerDependencies": {