n8n-nodes-twitter-media-upload 0.1.1

package/dist/credentials/TwitterMediaUploadApi.credentials.d.ts

@@ -0,0 +1,8 @@
+import { IAuthenticateGeneric, ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class TwitterMediaUploadApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+}

package/dist/credentials/TwitterMediaUploadApi.credentials.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TwitterMediaUploadApi = void 0;
+class TwitterMediaUploadApi {
+    constructor() {
+        this.name = 'twitterMediaUploadApi';
+        this.displayName = 'Twitter Media Upload API';
+        this.documentationUrl = 'https://developer.twitter.com/en/docs/twitter-api';
+        this.properties = [
+            {
+                displayName: 'Consumer Key',
+                name: 'consumerKey',
+                type: 'string',
+                default: '',
+                required: true,
+                description: 'Twitter API Consumer Key (API Key)',
+            },
+            {
+                displayName: 'Consumer Secret',
+                name: 'consumerSecret',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                default: '',
+                required: true,
+                description: 'Twitter API Consumer Secret (API Secret)',
+            },
+            {
+                displayName: 'Access Token',
+                name: 'accessToken',
+                type: 'string',
+                default: '',
+                required: true,
+                description: 'Twitter API Access Token',
+            },
+            {
+                displayName: 'Access Token Secret',
+                name: 'accessTokenSecret',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                default: '',
+                required: true,
+                description: 'Twitter API Access Token Secret',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                qs: {},
+            },
+        };
+    }
+}
+exports.TwitterMediaUploadApi = TwitterMediaUploadApi;

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

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

package/dist/nodes/TwitterMediaUpload/TwitterMediaUpload.node.js

@@ -0,0 +1,243 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TwitterMediaUpload = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const oauth_1_0a_1 = __importDefault(require("oauth-1.0a"));
+const crypto_js_1 = __importDefault(require("crypto-js"));
+class TwitterMediaUpload {
+    constructor() {
+        this.description = {
+            displayName: 'Twitter Media Upload',
+            name: 'twitterMediaUpload',
+            icon: 'file:twitter.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"]}}',
+            description: 'Upload media files to Twitter/X',
+            defaults: {
+                name: 'Twitter Media Upload',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'twitterMediaUploadApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Upload Media',
+                            value: 'upload',
+                            description: 'Upload media file to Twitter',
+                            action: 'Upload media file to Twitter',
+                        },
+                    ],
+                    default: 'upload',
+                },
+                {
+                    displayName: 'Binary Property',
+                    name: 'binaryPropertyName',
+                    type: 'string',
+                    default: 'data',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['upload'],
+                        },
+                    },
+                    description: 'Name of the binary property which contains the file to upload',
+                },
+                {
+                    displayName: 'Media Type',
+                    name: 'mediaType',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Image (PNG)',
+                            value: 'image/png',
+                        },
+                        {
+                            name: 'Image (JPEG)',
+                            value: 'image/jpeg',
+                        },
+                        {
+                            name: 'Image (GIF)',
+                            value: 'image/gif',
+                        },
+                        {
+                            name: 'Image (WebP)',
+                            value: 'image/webp',
+                        },
+                        {
+                            name: 'Video (MP4)',
+                            value: 'video/mp4',
+                        },
+                        {
+                            name: 'Video (MOV)',
+                            value: 'video/quicktime',
+                        },
+                        {
+                            name: 'Custom',
+                            value: 'custom',
+                        },
+                    ],
+                    default: 'image/png',
+                    displayOptions: {
+                        show: {
+                            operation: ['upload'],
+                        },
+                    },
+                    description: 'The MIME type of the media being uploaded',
+                },
+                {
+                    displayName: 'Custom Media Type',
+                    name: 'customMediaType',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            operation: ['upload'],
+                            mediaType: ['custom'],
+                        },
+                    },
+                    description: 'Custom MIME type (e.g., audio/mpeg)',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = await this.getCredentials('twitterMediaUploadApi');
+        // Setup OAuth1
+        const oauth = new oauth_1_0a_1.default({
+            consumer: {
+                key: credentials.consumerKey,
+                secret: credentials.consumerSecret,
+            },
+            signature_method: 'HMAC-SHA1',
+            hash_function(base_string, key) {
+                return crypto_js_1.default.HmacSHA1(base_string, key).toString(crypto_js_1.default.enc.Base64);
+            },
+        });
+        const token = {
+            key: credentials.accessToken,
+            secret: credentials.accessTokenSecret,
+        };
+        const TWITTER_UPLOAD_URL = 'https://upload.twitter.com/1.1/media/upload.json';
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            try {
+                const operation = this.getNodeParameter('operation', itemIndex);
+                if (operation === 'upload') {
+                    const binaryPropertyName = this.getNodeParameter('binaryPropertyName', itemIndex);
+                    const mediaType = this.getNodeParameter('mediaType', itemIndex);
+                    const customMediaType = this.getNodeParameter('customMediaType', itemIndex, '');
+                    const finalMediaType = mediaType === 'custom' ? customMediaType : mediaType;
+                    // Get binary data
+                    const binaryData = this.helpers.assertBinaryData(itemIndex, binaryPropertyName);
+                    const fileBuffer = await this.helpers.getBinaryDataBuffer(itemIndex, binaryPropertyName);
+                    const totalBytes = fileBuffer.length;
+                    // INIT
+                    const initData = {
+                        command: 'INIT',
+                        total_bytes: totalBytes.toString(),
+                        media_type: finalMediaType,
+                    };
+                    const initRequest = {
+                        url: TWITTER_UPLOAD_URL,
+                        method: 'POST',
+                        data: initData,
+                    };
+                    const initAuth = oauth.authorize(initRequest, token);
+                    const initResponse = await this.helpers.request({
+                        method: 'POST',
+                        url: TWITTER_UPLOAD_URL,
+                        headers: oauth.toHeader(initAuth),
+                        form: initData,
+                        json: true,
+                    });
+                    const mediaId = initResponse.media_id_string;
+                    // APPEND
+                    const appendRequest = {
+                        url: TWITTER_UPLOAD_URL,
+                        method: 'POST',
+                    };
+                    const appendAuth = oauth.authorize(appendRequest, token);
+                    await this.helpers.request({
+                        method: 'POST',
+                        url: TWITTER_UPLOAD_URL,
+                        headers: {
+                            ...oauth.toHeader(appendAuth),
+                        },
+                        formData: {
+                            command: 'APPEND',
+                            media_id: mediaId,
+                            segment_index: '0',
+                            media: {
+                                value: fileBuffer,
+                                options: {
+                                    filename: binaryData.fileName || 'file',
+                                    contentType: finalMediaType,
+                                },
+                            },
+                        },
+                    });
+                    // FINALIZE
+                    const finalizeData = {
+                        command: 'FINALIZE',
+                        media_id: mediaId,
+                    };
+                    const finalizeRequest = {
+                        url: TWITTER_UPLOAD_URL,
+                        method: 'POST',
+                        data: finalizeData,
+                    };
+                    const finalizeAuth = oauth.authorize(finalizeRequest, token);
+                    const finalizeResponse = await this.helpers.request({
+                        method: 'POST',
+                        url: TWITTER_UPLOAD_URL,
+                        headers: oauth.toHeader(finalizeAuth),
+                        form: finalizeData,
+                        json: true,
+                    });
+                    returnData.push({
+                        json: {
+                            media_id: mediaId,
+                            media_id_string: finalizeResponse.media_id_string,
+                            size: finalizeResponse.size,
+                            expires_after_secs: finalizeResponse.expires_after_secs,
+                            media_type: finalMediaType,
+                        },
+                        pairedItem: itemIndex,
+                    });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error.message,
+                        },
+                        pairedItem: itemIndex,
+                    });
+                    continue;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, {
+                    itemIndex,
+                });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.TwitterMediaUpload = TwitterMediaUpload;

package/dist/nodes/TwitterMediaUpload/twitter.svg

@@ -0,0 +1,22 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" fill="none">
+  <defs>
+    <radialGradient id="bg" cx="50%" cy="40%" r="60%">
+      <stop offset="0%" stop-color="#1A1A1A"/>
+      <stop offset="100%" stop-color="#000000"/>
+    </radialGradient>
+  </defs>
+
+  <!-- Rounded dark badge -->
+  <rect width="100" height="100" rx="18" fill="url(#bg)"/>
+
+  <!-- Outer glow ring -->
+  <circle cx="50" cy="50" r="46" stroke="#111" stroke-width="2"/>
+
+  <!-- X Logo -->
+  <path d="M26 22 L46 22 L74 78 L54 78 Z" fill="#E6E6E6"/>
+  <path d="M54 22 L74 22 L46 78 L26 78 Z" fill="#E6E6E6"/>
+
+  <!-- Inner cut for futuristic depth -->
+  <path d="M34 26 L46 26 L66 74 L54 74 Z" fill="#0B0B0B"/>
+  <path d="M54 26 L66 26 L46 74 L34 74 Z" fill="#0B0B0B"/>
+</svg>

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "n8n-nodes-twitter-media-upload",
+  "version": "0.1.1",
+  "description": "n8n node for uploading media to Twitter/X",
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "twitter",
+    "media",
+    "upload"
+  ],
+  "license": "MIT",
+  "homepage": "",
+  "author": {
+    "name": "Your Name",
+    "email": "your.email@example.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/deepakdhaka-1/n8n-nodes-twitter-media-upload/"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && gulp build:icons",
+    "dev": "tsc --watch",
+    "format": "prettier nodes credentials --write",
+    "lint": "eslint **/*.ts",
+    "lintfix": "eslint **/*.ts --fix",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/TwitterMediaUploadApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/TwitterMediaUpload/TwitterMediaUpload.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@typescript-eslint/parser": "^5.30.0",
+    "eslint": "^8.0.0",
+    "eslint-plugin-n8n-nodes-base": "^1.11.0",
+    "gulp": "^4.0.2",
+    "n8n-workflow": "*",
+    "prettier": "^2.7.1",
+    "typescript": "^4.8.0"
+  },
+  "dependencies": {
+    "oauth-1.0a": "^2.2.6",
+    "crypto-js": "^4.1.1"
+  }
+}