n8n-nodes-oidc-login 0.1.0

package/README.md

@@ -0,0 +1,108 @@
+# n8n-nodes-oidc-login
+
+Community-Node-Package für einen **OIDC-Login-Flow, der von einem eingehenden Webhook/Web-Formular
+ausgelöst wird** und dessen Access Token danach in nachfolgenden HTTP-Request-Nodes per eigenem
+Credential-Typ genutzt werden kann.
+
+## Enthaltene Bausteine
+
+| Datei | Zweck |
+|---|---|
+| `credentials/OidcProviderApi.credentials.ts` | Statische Provider-Settings (Client ID/Secret, Authorization-/Token-URL). Wird **vom Trigger-Node** gelesen. |
+| `nodes/OidcLoginTrigger/OidcLoginTrigger.node.ts` | Webhook-Trigger mit zwei Endpunkten: Login-Start (Redirect zum OIDC-Server) und Callback (Code-Exchange). |
+| `credentials/OidcBearerApi.credentials.ts` | Credential mit Feld `Access Token`, **wählbar in jedem HTTP Request Node**. Wert wird per Expression pro Ausführung befüllt. |
+
+## Antwortverhalten des Callback-Webhooks
+
+Der Callback-Endpunkt (`.../oidc-login/callback`) nutzt `responseMode: 'lastNode'`: Der Browser/Client,
+der nach dem Gitea-Login auf diese URL zurückgeleitet wird, bekommt **keine sofortige "Login erfolgreich"-Seite**,
+sondern n8n lässt die Verbindung offen, bis der komplette Workflow durchgelaufen ist, und schickt dann
+automatisch die Ausgabe der **letzten Node** im Workflow als JSON-Antwort zurück. Baut man z. B. einen
+HTTP-Request-Node (Repos abrufen) + Set-Node (Formatierung) dahinter, landet exakt deren Output als
+JSON-Antwort beim aufrufenden Client.
+
+Für Fehlerfälle (ungültiger `state`, Token-Austausch fehlgeschlagen) wird weiterhin sofort und manuell
+geantwortet (HTTP 400/502), da der Workflow dort nicht weiterläuft.
+
+## Warum zwei getrennte Credential-Typen?
+
+- `OidcProviderApi` ist **statisch** (Client ID/Secret ändern sich nicht) → normale, fest gespeicherte Credential.
+- `OidcBearerApi` ist **dynamisch pro Endnutzer/Ausführung** — n8n löst Expressions in Credential-Feldern
+  innerhalb des Kontexts der jeweiligen Workflow-Ausführung auf. Damit bekommt jeder Website-Besucher
+  in seiner eigenen Ausführung automatisch seinen eigenen, frisch erhaltenen Token — ohne dass Tokens
+  zwischen Nutzern/Ausführungen vermischt werden.
+
+## Ablauf
+
+1. Endnutzer ruft `https://<n8n>/webhook/oidc-login` auf (z. B. Link/Redirect aus einem Formular).
+2. `OidcLoginTrigger` generiert `state` + PKCE `code_verifier`/`code_challenge`, merkt sich beides
+   kurzzeitig in Workflow-Static-Data und leitet (HTTP 302) zur `authorizationUrl` des OIDC-Servers weiter.
+3. Nutzer meldet sich beim Auth-Server an. Dieser leitet zurück auf
+   `https://<n8n>/webhook/oidc-login/callback?code=...&state=...`.
+4. `OidcLoginTrigger` verifiziert `state`, tauscht `code` gegen Access Token (`POST` an `tokenUrl`,
+   inkl. `code_verifier`) und gibt den Token-Response-JSON (`access_token`, `id_token`, `expires_in`, …)
+   als Workflow-Output aus. Der Browser bekommt eine einfache "Anmeldung erfolgreich"-Seite.
+5. Alle nachfolgenden Nodes im Workflow haben Zugriff auf `$json.access_token`.
+
+## Einrichtung mit Gitea als OIDC-Server
+
+Gitea selbst als Auth-Server nutzt feste, nicht per Discovery konfigurierbare Endpunkte:
+
+- Authorization: `https://<gitea>/login/oauth/authorize`
+- Token: `https://<gitea>/login/oauth/access_token`
+- Userinfo (optional, für Profildaten): `https://<gitea>/login/oauth/userinfo`
+
+Schritte in Gitea:
+
+1. Als der Nutzer, unter dem die App laufen soll (oder als Admin unter *Site Administration →
+   Applications* für eine instanzweite OAuth2-App): **Settings → Applications → "Create a new OAuth2 Application"**.
+2. **Application Name** vergeben, als **Redirect URI** exakt die Callback-URL des `OidcLoginTrigger`
+   eintragen (z. B. `https://<n8n>/webhook/oidc-login/callback`) — muss zeichengenau übereinstimmen,
+   sonst meldet Gitea `redirect_uri_mismatch`.
+3. Gitea zeigt **Client ID** und **Client Secret** an (Secret nur einmal sichtbar!) → in die
+   `OIDC Provider`-Credential in n8n eintragen.
+4. **Scope**: `openid profile email` funktioniert bei Gitea für den OIDC-Login. Für Zugriff auf die
+   Gitea-API selbst (z. B. Repos lesen) ggf. zusätzlich Gitea-spezifische Scopes wie `read:repository`
+   ergänzen (Feld "Scope" im `OidcLoginTrigger`-Node), siehe Gitea-Doku zu "granular scopes".
+5. Optional: ein nachgeschalteter HTTP-Request-Node auf `https://<gitea>/login/oauth/userinfo` (GET,
+   Credential = `OIDC Bearer Token`) liefert die Profildaten des eingeloggten Gitea-Nutzers — guter Test,
+   ob der Flow funktioniert.
+
+## Einrichtung (allgemein)
+
+```bash
+npm install
+npm run build
+npm link
+# im n8n Custom-Extensions-Ordner:
+npm link n8n-nodes-oidc-login
+```
+
+n8n neu starten. Danach:
+
+1. **Credential "OIDC Provider"** anlegen: Authorization URL, Token URL, Client ID, (optional) Client Secret
+   eures OIDC-Servers eintragen.
+2. **Node "OIDC Login Trigger"** in den Workflow ziehen, die Credential auswählen, `Path` setzen
+   (z. B. `oidc-login`). n8n zeigt dir automatisch zwei Webhook-URLs an (Start + `.../callback`).
+3. Beim OIDC-Provider den **Callback-Webhook** (`.../oidc-login/callback`) als **Redirect URI** des Clients
+   registrieren.
+4. **Credential "OIDC Bearer Token"** anlegen: beim Feld "Access Token" auf **Expression** umschalten
+   und z. B. `={{ $json.access_token }}` eintragen (oder `={{ $('OIDC Login Trigger').item.json.access_token }}`,
+   falls dazwischen weitere Nodes liegen).
+5. Nachfolgenden **HTTP Request Node** hinzufügen → Authentication → "Predefined Credential Type" →
+   "OIDC Bearer Token" auswählen. Der `Authorization: Bearer <token>`-Header wird automatisch gesetzt.
+
+## Wichtige Einschränkungen / Hinweise
+
+- **Ein Token gilt nur für die Ausführung, in der er erzeugt wurde.** Das ist hier so gewollt
+  (jeder Endnutzer meldet sich selbst an), aber es bedeutet auch: Der Token wird nicht dauerhaft
+  gespeichert oder automatisch erneuert (kein Refresh-Token-Handling in diesem Minimalbeispiel).
+  Für Refresh-Logik müsste `refresh_token` aus `tokenResponse` zusätzlich ausgewertet und ein eigener
+  Refresh-Aufruf ergänzt werden.
+- **State-Speicherung** erfolgt über `this.getWorkflowStaticData('node')` (persistiert in der n8n-DB,
+  TTL 10 Minuten). Für sehr hohe Login-Frequenzen ggf. auf eine externe Datenbank/Cache umstellen.
+- **Sicherheit**: PKCE (S256) wird immer verwendet; Client Secret ist optional (für "public" Clients).
+  Stellt sicher, dass die n8n-Instanz per HTTPS erreichbar ist, da sensible Tokens durchlaufen.
+- Der HTTP Request Node muss in **derselben Workflow-Ausführung** wie der Login-Callback laufen
+  (direkt oder indirekt nachgeschaltet) — die Credential kann keinen Token aus einer anderen,
+  bereits abgeschlossenen Ausführung "nachladen".

package/dist/credentials/OidcBearerApi.credentials.d.ts

@@ -0,0 +1,22 @@
+import { ICredentialType, INodeProperties, IAuthenticateGeneric } from 'n8n-workflow';
+/**
+ * Credential für nachfolgende HTTP-Request-Nodes.
+ *
+ * WICHTIG: "Access Token" muss im Credential-UI über den kleinen
+ * Expression-Schalter (⚡/"Add Expression") auf einen Ausdruck umgestellt
+ * werden, z. B.:
+ *   ={{ $json.access_token }}
+ * oder, falls zwischen Trigger und HTTP-Request-Node weitere Nodes liegen:
+ *   ={{ $('OIDC Login Trigger').item.json.access_token }}
+ *
+ * n8n löst Expressions in Credential-Feldern pro Workflow-AUSFÜHRUNG auf
+ * (nicht global), d. h. jeder Endnutzer bekommt in seiner eigenen
+ * Ausführung automatisch seinen eigenen, gerade erhaltenen Token.
+ */
+export declare class OidcBearerApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+}

package/dist/credentials/OidcBearerApi.credentials.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OidcBearerApi = void 0;
+/**
+ * Credential für nachfolgende HTTP-Request-Nodes.
+ *
+ * WICHTIG: "Access Token" muss im Credential-UI über den kleinen
+ * Expression-Schalter (⚡/"Add Expression") auf einen Ausdruck umgestellt
+ * werden, z. B.:
+ *   ={{ $json.access_token }}
+ * oder, falls zwischen Trigger und HTTP-Request-Node weitere Nodes liegen:
+ *   ={{ $('OIDC Login Trigger').item.json.access_token }}
+ *
+ * n8n löst Expressions in Credential-Feldern pro Workflow-AUSFÜHRUNG auf
+ * (nicht global), d. h. jeder Endnutzer bekommt in seiner eigenen
+ * Ausführung automatisch seinen eigenen, gerade erhaltenen Token.
+ */
+class OidcBearerApi {
+    constructor() {
+        this.name = 'oidcBearerApi';
+        this.displayName = 'OIDC Bearer Token';
+        this.documentationUrl = 'https://docs.n8n.io/code/expressions/';
+        this.properties = [
+            {
+                displayName: 'Access Token',
+                name: 'accessToken',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                description: 'In der Regel als Expression setzen, z. B. ={{ $json.access_token }} — verweist auf den vom OIDC Login Trigger in DIESER Ausführung erhaltenen Token.',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    Authorization: '=Bearer {{$credentials.accessToken}}',
+                },
+            },
+        };
+    }
+}
+exports.OidcBearerApi = OidcBearerApi;

package/dist/credentials/OidcProviderApi.credentials.d.ts

@@ -0,0 +1,12 @@
+import { ICredentialType, INodeProperties } from 'n8n-workflow';
+/**
+ * Statische Konfiguration des OIDC-Providers. Wird ausschließlich vom
+ * OidcLoginTrigger-Node gelesen (per this.getCredentials), NICHT für
+ * "Generic Auth" an HTTP-Request-Nodes gedacht.
+ */
+export declare class OidcProviderApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+}

package/dist/credentials/OidcProviderApi.credentials.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OidcProviderApi = void 0;
+/**
+ * Statische Konfiguration des OIDC-Providers. Wird ausschließlich vom
+ * OidcLoginTrigger-Node gelesen (per this.getCredentials), NICHT für
+ * "Generic Auth" an HTTP-Request-Nodes gedacht.
+ */
+class OidcProviderApi {
+    constructor() {
+        this.name = 'oidcProviderApi';
+        this.displayName = 'OIDC Provider';
+        this.documentationUrl = 'https://openid.net/specs/openid-connect-core-1_0.html';
+        this.properties = [
+            {
+                displayName: 'Authorization URL',
+                name: 'authorizationUrl',
+                type: 'string',
+                default: 'https://gitea.example.com/login/oauth/authorize',
+                description: 'Bei Gitea fest: <Gitea-URL>/login/oauth/authorize',
+            },
+            {
+                displayName: 'Token URL',
+                name: 'tokenUrl',
+                type: 'string',
+                default: 'https://gitea.example.com/login/oauth/access_token',
+                description: 'Bei Gitea fest: <Gitea-URL>/login/oauth/access_token',
+            },
+            {
+                displayName: 'Client ID',
+                name: 'clientId',
+                type: 'string',
+                default: '',
+                required: true,
+            },
+            {
+                displayName: 'Client Secret',
+                name: 'clientSecret',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                description: 'Leer lassen, falls der Client als "public" (nur PKCE, kein Secret) registriert ist',
+            },
+        ];
+    }
+}
+exports.OidcProviderApi = OidcProviderApi;

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

@@ -0,0 +1,5 @@
+import { IHookFunctions, IWebhookFunctions, INodeType, INodeTypeDescription, IWebhookResponseData } from 'n8n-workflow';
+export declare class OidcLoginTrigger implements INodeType {
+    description: INodeTypeDescription;
+    webhook(this: IHookFunctions & IWebhookFunctions): Promise<IWebhookResponseData>;
+}

package/dist/nodes/OidcLoginTrigger/OidcLoginTrigger.node.js

@@ -0,0 +1,180 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OidcLoginTrigger = void 0;
+const crypto = __importStar(require("node:crypto"));
+const n8n_workflow_1 = require("n8n-workflow");
+const PENDING_TTL_MS = 10 * 60 * 1000; // 10 Minuten
+function base64url(input) {
+    return input.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+class OidcLoginTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'OIDC Login Trigger',
+            name: 'oidcLoginTrigger',
+            icon: 'fa:sign-in-alt',
+            group: ['trigger'],
+            version: 1,
+            description: 'Leitet einen eingehenden Webhook-/Formular-Request zum OIDC-Login weiter und stellt danach den Access Token als Workflow-Output bereit',
+            defaults: { name: 'OIDC Login Trigger' },
+            inputs: [],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            credentials: [
+                {
+                    name: 'oidcProviderApi',
+                    required: true,
+                },
+            ],
+            webhooks: [
+                {
+                    name: 'default',
+                    httpMethod: 'GET',
+                    responseMode: 'onReceived',
+                    path: '={{$parameter["path"]}}',
+                },
+                {
+                    name: 'callback',
+                    httpMethod: 'GET',
+                    // 'lastNode': n8n wartet mit der HTTP-Antwort, bis der gesamte Workflow
+                    // durchgelaufen ist, und sendet dann automatisch die Ausgabe der letzten
+                    // Node (hier: die formatierte Repo-Liste) als JSON-Response zurück.
+                    responseMode: 'lastNode',
+                    path: '={{$parameter["path"]}}/callback',
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Path',
+                    name: 'path',
+                    type: 'string',
+                    default: 'oidc-login',
+                    description: 'Basis-Pfad des Login-Webhooks. Der Callback läuft automatisch unter <Pfad>/callback — diese URL muss beim OIDC-Provider als Redirect URI hinterlegt werden.',
+                },
+                {
+                    displayName: 'Scope',
+                    name: 'scope',
+                    type: 'string',
+                    default: 'openid profile email',
+                },
+            ],
+        };
+    }
+    async webhook() {
+        var _a;
+        const webhookName = this.getWebhookName();
+        const req = this.getRequestObject();
+        const res = this.getResponseObject();
+        const credentials = (await this.getCredentials('oidcProviderApi'));
+        const staticData = this.getWorkflowStaticData('node');
+        if (!staticData.pending) {
+            staticData.pending = {};
+        }
+        // Abgelaufene Login-Versuche aufräumen
+        const now = Date.now();
+        for (const [key, value] of Object.entries(staticData.pending)) {
+            if (now - value.createdAt > PENDING_TTL_MS) {
+                delete staticData.pending[key];
+            }
+        }
+        if (webhookName === 'default') {
+            // --- Schritt 1: eingehender Request -> Redirect zum OIDC-Server ---
+            const state = crypto.randomBytes(16).toString('hex');
+            const codeVerifier = base64url(crypto.randomBytes(32));
+            const codeChallenge = base64url(crypto.createHash('sha256').update(codeVerifier).digest());
+            staticData.pending[state] = { codeVerifier, createdAt: now };
+            const redirectUri = this.getNodeWebhookUrl('callback');
+            const scope = this.getNodeParameter('scope') || 'openid profile email';
+            const authUrl = new URL(credentials.authorizationUrl);
+            authUrl.searchParams.set('response_type', 'code');
+            authUrl.searchParams.set('client_id', credentials.clientId);
+            authUrl.searchParams.set('redirect_uri', redirectUri);
+            authUrl.searchParams.set('scope', scope);
+            authUrl.searchParams.set('state', state);
+            authUrl.searchParams.set('code_challenge', codeChallenge);
+            authUrl.searchParams.set('code_challenge_method', 'S256');
+            res.writeHead(302, { Location: authUrl.toString() });
+            res.end();
+            // Workflow läuft für diesen Request NICHT weiter - erst der Callback tut das
+            return { noWebhookResponse: true };
+        }
+        // --- Schritt 2: Callback vom OIDC-Server ---
+        const query = req.query;
+        if (query.error) {
+            res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end(`<h1>Anmeldung fehlgeschlagen</h1><p>${(_a = query.error_description) !== null && _a !== void 0 ? _a : query.error}</p>`);
+            return { noWebhookResponse: true };
+        }
+        const pending = query.state ? staticData.pending[query.state] : undefined;
+        if (!query.code || !query.state || !pending) {
+            res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end('<h1>Ungültige oder abgelaufene Login-Anfrage</h1>');
+            return { noWebhookResponse: true };
+        }
+        delete staticData.pending[query.state];
+        const redirectUri = this.getNodeWebhookUrl('callback');
+        let tokenResponse;
+        try {
+            tokenResponse = (await this.helpers.httpRequest({
+                method: 'POST',
+                url: credentials.tokenUrl,
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+                body: new URLSearchParams({
+                    grant_type: 'authorization_code',
+                    code: query.code,
+                    redirect_uri: redirectUri,
+                    client_id: credentials.clientId,
+                    ...(credentials.clientSecret ? { client_secret: credentials.clientSecret } : {}),
+                    code_verifier: pending.codeVerifier,
+                }).toString(),
+                json: true,
+            }));
+        }
+        catch (error) {
+            res.writeHead(502, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end('<h1>Token-Austausch mit dem OIDC-Server fehlgeschlagen</h1>');
+            throw error;
+        }
+        // KEINE manuelle Antwort hier: responseMode 'lastNode' (siehe description.webhooks)
+        // sorgt dafür, dass n8n automatisch antwortet, sobald der Workflow durchgelaufen
+        // ist - mit der Ausgabe der letzten Node (z. B. die formatierte Repo-Liste) als JSON.
+        // tokenResponse (access_token, id_token, ...) steht nachfolgenden Nodes als $json
+        // zur Verfügung.
+        return {
+            workflowData: [[{ json: tokenResponse }]],
+        };
+    }
+}
+exports.OidcLoginTrigger = OidcLoginTrigger;

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "n8n-nodes-oidc-login",
+  "version": "0.1.0",
+  "description": "Custom credentials + web node for n8n",
+  "keywords": [
+    "n8n-community-node-package"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/OidcProviderApi.credentials.js",
+      "dist/credentials/OidcBearerApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/OidcLoginTrigger/OidcLoginTrigger.node.js"
+    ]
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc -p tsconfig.json --watch"
+  },
+  "devDependencies": {
+    "@types/node": "^26.4.0",
+    "n8n-workflow": "^1.60.0",
+    "typescript": "^5.4.0"
+  }
+}