n8n-nodes-postwire 0.2.3 → 0.3.0

package/dist/nodes/PostWire/PostWire.node.js

@@ -2,24 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostWire = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
-const BASE = 'https://postwire.io';
-// Every network PostWire can publish to. `mediaNeed` mirrors the server's own rule so the node can
-// warn in the editor rather than letting the call fail — TikTok and YouTube refuse a post with no
-// video, and Instagram refuses one with no media at all.
-const PLATFORMS = [
-    { name: 'TikTok', value: 'tiktok', mediaNeed: 'video' },
-    { name: 'Instagram', value: 'instagram', mediaNeed: 'any' },
-    { name: 'YouTube', value: 'youtube', mediaNeed: 'video' },
-    { name: 'LinkedIn', value: 'linkedin', mediaNeed: null },
-    { name: 'X (Twitter)', value: 'x', mediaNeed: null },
-    { name: 'Facebook', value: 'facebook', mediaNeed: null },
-    { name: 'Reddit', value: 'reddit', mediaNeed: null },
-    { name: 'Bluesky', value: 'bluesky', mediaNeed: null },
-    { name: 'Mastodon', value: 'mastodon', mediaNeed: null },
-    { name: 'Telegram', value: 'telegram', mediaNeed: null },
-    { name: 'Discord', value: 'discord', mediaNeed: null },
-];
-const needOf = (value) => PLATFORMS.find((p) => p.value === value)?.mediaNeed ?? null;
+const Description_1 = require("./Description");
+const GenericFunctions_1 = require("./GenericFunctions");
+const LegacyDescription_1 = require("./LegacyDescription");
+const LEGACY = {
+    me: { resource: 'account', operation: 'get' },
+    publish: { resource: 'post', operation: 'publish', contentMode: 'text' },
+    generateAndPublish: { resource: 'post', operation: 'publish', contentMode: 'smart' },
+    generate: { resource: 'post', operation: 'generate' },
+    schedule: { resource: 'post', operation: 'schedule', contentMode: 'text' },
+};
+function locatorValue(v) {
+    var _a;
+    if (v && typeof v === 'object')
+        return String((_a = v.value) !== null && _a !== void 0 ? _a : '').trim();
+    return String(v !== null && v !== void 0 ? v : '').trim();
+}
 class PostWire {
     constructor() {
         this.description = {
@@ -27,310 +25,445 @@ class PostWire {
             name: 'postWire',
             icon: { light: 'file:postwire.svg', dark: 'file:postwire.dark.svg' },
             group: ['output'],
-            version: 1,
-            subtitle: '={{$parameter["operation"]}}',
-            description: 'Publish one idea natively to every social network',
-            // An agent asking to post is exactly the use this node was built for.
+            version: [1, 2],
+            defaultVersion: 2,
+            subtitle: '={{$parameter["operation"] + ($parameter["resource"] ? ": " + $parameter["resource"] : "")}}',
+            description: 'Publish one idea natively to TikTok, Instagram, YouTube, LinkedIn, X, Bluesky and more — a different post written for each network',
             usableAsTool: true,
             defaults: { name: 'PostWire' },
             inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
             outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
             credentials: [{ name: 'postWireApi', required: true }],
-            requestDefaults: {
-                baseURL: BASE,
-                headers: { 'Content-Type': 'application/json' },
-            },
             properties: [
-                {
-                    displayName: 'Operation',
-                    name: 'operation',
-                    type: 'options',
-                    noDataExpression: true,
-                    options: [
-                        {
-                            name: 'Get Account',
-                            value: 'me',
-                            description: 'Plan, usage this month and connected accounts',
-                            action: 'Get account',
-                        },
-                        {
-                            name: 'Publish',
-                            value: 'publish',
-                            description: 'Publish to one or more networks in a single call',
-                            action: 'Publish to social networks',
-                        },
-                        {
-                            name: 'Schedule',
-                            value: 'schedule',
-                            description: 'Queue a post for a later time',
-                            action: 'Schedule a post',
-                        },
-                        {
-                            name: 'Write a Post per Network',
-                            value: 'generate',
-                            description: 'One prompt in, a native draft out for each network — right length, hashtags and format per platform. Does not publish.',
-                            action: 'Write a native post for each network',
-                        },
-                        {
-                            name: 'Write and Publish',
-                            value: 'generateAndPublish',
-                            description: 'Write a native draft per network, then publish them',
-                            action: 'Write and publish in one step',
-                        },
-                    ],
-                    default: 'generateAndPublish',
-                },
-                {
-                    displayName: 'Networks',
-                    name: 'platforms',
-                    type: 'multiOptions',
-                    options: PLATFORMS.map((p) => ({ name: p.name, value: p.value })),
-                    default: ['x', 'linkedin'],
-                    required: true,
-                    description: 'Connect these in the PostWire dashboard first. TikTok, Instagram and YouTube are one OAuth click — PostWire carries the platform approvals, so there is no app review on your side.',
-                    displayOptions: {
-                        show: { operation: ['generate', 'publish', 'generateAndPublish', 'schedule'] },
-                    },
-                },
-                {
-                    displayName: 'Idea',
-                    name: 'prompt',
-                    type: 'string',
-                    typeOptions: { rows: 3 },
-                    default: '',
-                    required: true,
-                    placeholder: 'We shipped scheduling today — one idea, a native post per network',
-                    description: 'What you want to say. More detail gives a better draft.',
-                    displayOptions: { show: { operation: ['generate', 'generateAndPublish'] } },
-                },
-                {
-                    displayName: 'Text',
-                    name: 'text',
-                    type: 'string',
-                    typeOptions: { rows: 3 },
-                    default: '',
-                    description: 'Posted exactly as written to every selected network',
-                    displayOptions: { show: { operation: ['publish', 'schedule'] } },
-                },
-                {
-                    displayName: 'Media URL',
-                    name: 'mediaUrl',
-                    type: 'string',
-                    default: '',
-                    placeholder: 'https://example.com/clip.mp4',
-                    description: 'A direct link to an .mp4 or an image. TikTok and YouTube will not accept a post without a video, and Instagram needs a photo or a video. A Google Drive share link does not work — it returns a web page, not a file.',
-                    displayOptions: {
-                        show: { operation: ['generate', 'publish', 'generateAndPublish', 'schedule'] },
-                    },
-                },
-                {
-                    displayName: 'Publish At',
-                    name: 'runAt',
-                    type: 'dateTime',
-                    default: '',
-                    required: true,
-                    description: 'When to publish. PostWire validates the post now, so a missing video is caught here rather than at 7am tomorrow.',
-                    displayOptions: { show: { operation: ['schedule'] } },
-                },
-                {
-                    displayName: 'Options',
-                    name: 'options',
-                    type: 'collection',
-                    placeholder: 'Add option',
-                    default: {},
-                    displayOptions: {
-                        show: { operation: ['generate', 'publish', 'generateAndPublish', 'schedule'] },
-                    },
-                    options: [
-                        {
-                            displayName: 'Media Type',
-                            name: 'mediaType',
-                            type: 'options',
-                            default: 'auto',
-                            options: [
-                                { name: 'Detect From the URL', value: 'auto' },
-                                { name: 'Video', value: 'video' },
-                                { name: 'Image', value: 'image' },
-                            ],
-                            description: 'Only needed when the link has no file extension — a signed CDN URL or a share link. Detection reads the extension and, when there is none, follows what the chosen networks require.',
-                        },
-                        {
-                            displayName: 'Brand',
-                            name: 'brandId',
-                            type: 'string',
-                            default: '',
-                            description: 'Publish as a specific brand. Leave empty for your only brand.',
-                        },
-                        {
-                            displayName: 'Brand Voice',
-                            name: 'brandVoice',
-                            type: 'string',
-                            default: '',
-                            description: 'A sentence describing how you want to sound, applied to every generated draft',
-                        },
-                        {
-                            displayName: 'Title (YouTube)',
-                            name: 'title',
-                            type: 'string',
-                            default: '',
-                            description: 'Overrides the generated YouTube title',
-                        },
-                        {
-                            displayName: 'Visibility',
-                            name: 'privacy',
-                            type: 'options',
-                            options: [
-                                { name: 'Private', value: 'private' },
-                                { name: 'Public', value: 'public' },
-                                { name: 'Unlisted', value: 'unlisted' },
-                            ],
-                            default: 'public',
-                            description: 'Used by TikTok and YouTube',
-                        },
-                    ],
-                },
+                ...LegacyDescription_1.legacyProperties,
+                Description_1.resourceProperty,
+                ...Description_1.operationProperties,
+                ...Description_1.postProperties,
+                ...Description_1.scheduledPostProperties,
+                ...Description_1.brandProperties,
+                ...Description_1.connectionProperties,
+                ...Description_1.accountProperties,
+                ...Description_1.mediaProperties,
             ],
         };
+        this.methods = {
+            listSearch: {
+                async searchBrands(filter) {
+                    const res = await GenericFunctions_1.apiRequest.call(this, 'GET', '/api/brands');
+                    const brands = res.brands || [];
+                    const f = (filter || '').toLowerCase();
+                    return {
+                        results: brands
+                            .filter((b) => !f || String(b.name).toLowerCase().includes(f))
+                            .map((b) => {
+                            var _a;
+                            return ({
+                                name: `${b.name}${((_a = b.platforms) === null || _a === void 0 ? void 0 : _a.length) ? ` (${b.platforms.map(GenericFunctions_1.nameOf).join(', ')})` : ''}`,
+                                value: b.id,
+                            });
+                        }),
+                    };
+                },
+            },
+        };
     }
     async execute() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         const items = this.getInputData();
         const out = [];
+        const version = this.getNode().typeVersion;
         for (let i = 0; i < items.length; i++) {
             try {
-                const operation = this.getNodeParameter('operation', i);
-                if (operation === 'me') {
-                    const me = (await this.helpers.httpRequestWithAuthentication.call(this, 'postWireApi', {
-                        method: 'GET',
-                        url: `${BASE}/api/me`,
-                        json: true,
-                    }));
-                    out.push({ json: me, pairedItem: { item: i } });
+                let resource;
+                let operation;
+                let legacyMode;
+                if (version === 1) {
+                    const legacy = LEGACY[this.getNodeParameter('operation', i)];
+                    if (!legacy)
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Unknown operation', { itemIndex: i });
+                    ({ resource, operation } = legacy);
+                    legacyMode = legacy.contentMode;
+                }
+                else {
+                    resource = this.getNodeParameter('resource', i);
+                    operation = this.getNodeParameter('operation', i);
+                }
+                const push = (json) => out.push({ json, pairedItem: { item: i } });
+                if (resource === 'account') {
+                    const me = await GenericFunctions_1.apiRequest.call(this, 'GET', '/api/me', undefined, undefined, i);
+                    const simplify = version === 1 ? false : this.getNodeParameter('simplify', i, true);
+                    if (!simplify) {
+                        push(me);
+                        continue;
+                    }
+                    const usage = me.usage || {};
+                    const brands = me.brands || {};
+                    push({
+                        email: me.email,
+                        plan: me.plan,
+                        posts_used: usage.posts,
+                        posts_limit: usage.limit,
+                        brands_used: brands.used,
+                        brands_limit: brands.limit,
+                        connected: (me.connections || []).map((c) => c.platform),
+                        verified: me.verified,
+                        account_id: me.account_id,
+                    });
+                    continue;
+                }
+                if (resource === 'media') {
+                    const field = this.getNodeParameter('binaryPropertyName', i);
+                    push(await GenericFunctions_1.uploadBinary.call(this, i, field));
+                    continue;
+                }
+                if (resource === 'brand') {
+                    if (operation === 'getAll') {
+                        const res = await GenericFunctions_1.apiRequest.call(this, 'GET', '/api/brands', undefined, undefined, i);
+                        let list = res.brands || [];
+                        if (!this.getNodeParameter('returnAll', i))
+                            list = list.slice(0, this.getNodeParameter('limit', i));
+                        for (const b of list)
+                            push(b);
+                        continue;
+                    }
+                    if (operation === 'create') {
+                        const res = await GenericFunctions_1.apiRequest.call(this, 'POST', '/api/brands', {
+                            name: this.getNodeParameter('name', i),
+                        }, undefined, i);
+                        push(res.brand || res);
+                        continue;
+                    }
+                    const id = locatorValue(this.getNodeParameter('brand', i));
+                    if (operation === 'update') {
+                        const res = await GenericFunctions_1.apiRequest.call(this, 'PATCH', `/api/brands/${encodeURIComponent(id)}`, {
+                            name: this.getNodeParameter('name', i),
+                        }, undefined, i);
+                        push(res.brand || res);
+                        continue;
+                    }
+                    if (operation === 'delete') {
+                        await GenericFunctions_1.apiRequest.call(this, 'DELETE', `/api/brands/${encodeURIComponent(id)}`, undefined, undefined, i);
+                        push({ deleted: true, id });
+                        continue;
+                    }
+                }
+                if (resource === 'connection') {
+                    if (operation === 'getAll') {
+                        const me = await GenericFunctions_1.apiRequest.call(this, 'GET', '/api/me', undefined, undefined, i);
+                        const brandName = new Map((me.brand_list || []).map((b) => [b.id, b.name]));
+                        let list = (me.connections || []).map((c) => {
+                            var _a;
+                            return ({
+                                ...c,
+                                network: (0, GenericFunctions_1.nameOf)(c.platform),
+                                brand_name: (_a = brandName.get(c.brand_id)) !== null && _a !== void 0 ? _a : null,
+                            });
+                        });
+                        if (!this.getNodeParameter('returnAll', i))
+                            list = list.slice(0, this.getNodeParameter('limit', i));
+                        for (const c of list)
+                            push(c);
+                        continue;
+                    }
+                    if (operation === 'checkHealth') {
+                        const platform = this.getNodeParameter('platform', i);
+                        push(await GenericFunctions_1.apiRequest.call(this, 'GET', `/api/connect/${platform}/health`, undefined, undefined, i));
+                        continue;
+                    }
+                    if (operation === 'createConnectLink') {
+                        const platform = this.getNodeParameter('platform', i, '');
+                        push(await GenericFunctions_1.apiRequest.call(this, 'POST', '/api/connect-link', platform ? { platform } : {}, undefined, i));
+                        continue;
+                    }
+                }
+                if (resource === 'scheduledPost') {
+                    if (operation === 'getAll') {
+                        const filters = this.getNodeParameter('filters', i, {});
+                        const qs = {};
+                        if (filters.from)
+                            qs.from = new Date(filters.from).toISOString();
+                        if (filters.to)
+                            qs.to = new Date(filters.to).toISOString();
+                        const res = await GenericFunctions_1.apiRequest.call(this, 'GET', '/api/schedule', undefined, qs, i);
+                        let list = res.scheduled || [];
+                        if (filters.status)
+                            list = list.filter((r) => r.status === filters.status);
+                        if (!this.getNodeParameter('returnAll', i))
+                            list = list.slice(0, this.getNodeParameter('limit', i));
+                        for (const r of list)
+                            push(r);
+                        continue;
+                    }
+                    const id = encodeURIComponent(this.getNodeParameter('scheduledPostId', i));
+                    if (operation === 'delete') {
+                        await GenericFunctions_1.apiRequest.call(this, 'DELETE', `/api/schedule/${id}`, undefined, undefined, i);
+                        push({ deleted: true, id: decodeURIComponent(id) });
+                        continue;
+                    }
+                    if (operation === 'update') {
+                        const fields = this.getNodeParameter('updateFields', i, {});
+                        const body = {};
+                        if (fields.runAt)
+                            body.run_at = new Date(fields.runAt).toISOString();
+                        if (fields.label !== undefined)
+                            body.label = fields.label;
+                        if (!Object.keys(body).length)
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Nothing to update', {
+                                itemIndex: i,
+                                description: "Add 'Publish At' or 'Label' under 'Update Fields'.",
+                            });
+                        const res = await GenericFunctions_1.apiRequest.call(this, 'PATCH', `/api/schedule/${id}`, body, undefined, i);
+                        push(res.scheduled || res);
+                        continue;
+                    }
+                }
+                if (resource !== 'post')
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Unknown operation', { itemIndex: i });
+                if (operation === 'getStatus') {
+                    const platform = this.getNodeParameter('statusPlatform', i);
+                    const id = String((_a = this.getNodeParameter('postId', i)) !== null && _a !== void 0 ? _a : '').trim();
+                    push(await GenericFunctions_1.apiRequest.call(this, 'GET', '/api/post/status', undefined, { platform, id }, i));
                     continue;
                 }
-                const platforms = this.getNodeParameter('platforms', i);
+                const platforms = (this.getNodeParameter('platforms', i, []) || []).filter(Boolean);
                 const opts = this.getNodeParameter('options', i, {});
-                const mediaUrl = (this.getNodeParameter('mediaUrl', i, '') || '').trim();
-                if (!platforms?.length) {
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Pick at least one network.', {
+                if (!platforms.length)
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), "No network selected in 'Networks'", {
                         itemIndex: i,
+                        description: 'Pick at least one network. They must be connected in the PostWire dashboard.',
                     });
+                if (operation === 'planWeek') {
+                    const video = platforms.filter((p) => (0, GenericFunctions_1.needOf)(p));
+                    if (video.length)
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `${video.map(GenericFunctions_1.nameOf).join(', ')} cannot be in a week plan`, {
+                            itemIndex: i,
+                            description: 'A week plan is text only. Schedule video posts one by one with Post → Schedule.',
+                        });
+                    const tz = (opts.timezone || this.getTimezone() || 'UTC').trim();
+                    let offset;
+                    try {
+                        offset = (0, GenericFunctions_1.tzOffsetMinutes)(tz);
+                    }
+                    catch {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `'Timezone' is not a known time zone: "${tz}"`, {
+                            itemIndex: i,
+                            description: 'Use an IANA name such as America/New_York or Europe/Madrid.',
+                        });
+                    }
+                    const res = await GenericFunctions_1.apiRequest.call(this, 'POST', '/api/week', {
+                        topic: this.getNodeParameter('topic', i),
+                        platforms,
+                        days: this.getNodeParameter('days', i, 5),
+                        start_hour: this.getNodeParameter('hour', i, 10),
+                        tz_offset_minutes: offset,
+                        brand_voice: opts.brandVoice || undefined,
+                    }, undefined, i);
+                    push({ ...res, timezone: tz });
+                    continue;
                 }
-                // Media rules, checked before the request so the message names the fix rather than the symptom.
-                //
-                // The classifier used to answer only video-or-photo, and called everything without a
-                // known video extension a photo. A signed CDN link, one ending in #t=30, or a share URL
-                // with no extension at all was therefore "a photo", and the check below then threw and
-                // stopped the whole workflow — for a video that would have published perfectly well.
-                // Three answers now, and an unknown one is never grounds for refusing to try: the
-                // network is the thing that gets to decide, not a regular expression over a filename.
-                const declared = opts.mediaType || 'auto';
-                const kind = !mediaUrl
-                    ? 'none'
-                    : declared === 'video' || declared === 'image'
-                        ? declared
-                        : /\.(mp4|mov|webm|m3u8|avi|mkv|m4v)(\?|#|$)/i.test(mediaUrl)
-                            ? 'video'
-                            : /\.(jpe?g|png|gif|webp|heic|heif|avif|bmp|tiff?)(\?|#|$)/i.test(mediaUrl)
-                                ? 'image'
-                                : 'unknown';
-                const blocked = platforms.filter((p) => {
-                    const need = needOf(p);
-                    if (!need)
-                        return false;
-                    if (need === 'video')
-                        return kind === 'image' || kind === 'none';
-                    return kind === 'none';
-                });
+                const mediaSource = version === 1
+                    ? (this.getNodeParameter('mediaUrl', i, '') ? 'url' : 'none')
+                    : this.getNodeParameter('mediaSource', i, 'none');
+                let mediaUrl = '';
+                let declared = opts.mediaType || 'auto';
+                if (mediaSource === 'url')
+                    mediaUrl = String(this.getNodeParameter('mediaUrl', i, '') || '').trim();
+                if (mediaSource === 'binary') {
+                    const field = this.getNodeParameter('binaryPropertyName', i);
+                    const hosted = await GenericFunctions_1.uploadBinary.call(this, i, field);
+                    mediaUrl = hosted.media_url;
+                    const ct = String(hosted.content_type || this.helpers.assertBinaryData(i, field).mimeType || '');
+                    if (declared === 'auto')
+                        declared = ct.startsWith('video/') ? 'video' : ct.startsWith('image/') ? 'image' : 'auto';
+                }
+                if (operation === 'generate') {
+                    const prompt = this.getNodeParameter('prompt', i);
+                    const { drafts, missing } = await GenericFunctions_1.generateDrafts.call(this, i, {
+                        prompt,
+                        platforms,
+                        media_url: mediaUrl || undefined,
+                        brand_voice: opts.brandVoice || undefined,
+                    });
+                    push({
+                        drafts,
+                        ...(missing.length ? { missing } : {}),
+                        platforms,
+                        media_url: mediaUrl || undefined,
+                        preview: (0, GenericFunctions_1.draftsPreview)(drafts),
+                    });
+                    continue;
+                }
+                const contentMode = legacyMode !== null && legacyMode !== void 0 ? legacyMode : this.getNodeParameter('contentMode', i, 'smart');
+                const kind = (0, GenericFunctions_1.classifyMedia)(mediaUrl, declared);
+                const blocked = (0, GenericFunctions_1.mediaBlocks)(platforms, kind);
                 if (blocked.length) {
-                    const wantsVideo = blocked.some((p) => needOf(p) === 'video');
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `${blocked.join(' and ')} will not accept a post without ${wantsVideo ? 'a video' : 'an image or video'}. Set Media URL to a direct file link, or remove ${blocked.length > 1 ? 'those networks' : 'that network'} from the list.`, { itemIndex: i });
+                    const wantsVideo = blocked.some((p) => (0, GenericFunctions_1.needOf)(p) === 'video');
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `${blocked.map(GenericFunctions_1.nameOf).join(' and ')} will not accept a post without ${wantsVideo ? 'a video' : 'an image or video'}`, {
+                        itemIndex: i,
+                        description: `Set 'Media' to a video URL or to "Binary File", or remove ${blocked.length > 1 ? 'those networks' : 'that network'} from 'Networks'.`,
+                    });
+                }
+                if (mediaSource === 'url' && mediaUrl && !opts.skipMediaCheck) {
+                    const why = await (0, GenericFunctions_1.checkMediaUrl)(this, mediaUrl, platforms);
+                    if (why)
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'The media link cannot be published', {
+                            itemIndex: i,
+                            description: why,
+                        });
                 }
-                // An unrecognised link still has to go in one of the two fields the API has. Send it as the
-                // one the chosen networks need — that is the only reading of it that can succeed.
-                const treatAsVideo = kind === 'video' || (kind === 'unknown' && platforms.some((p) => needOf(p) === 'video'));
-                const videoUrl = mediaUrl && treatAsVideo ? mediaUrl : undefined;
-                const photoUrl = mediaUrl && !treatAsVideo ? mediaUrl : undefined;
+                const treatAsVideo = kind === 'video' || (kind === 'unknown' && platforms.some((p) => (0, GenericFunctions_1.needOf)(p) === 'video'));
                 let perPlatform;
-                if (operation === 'generate' || operation === 'generateAndPublish') {
-                    const prompt = this.getNodeParameter('prompt', i);
-                    const gen = (await this.helpers.httpRequestWithAuthentication.call(this, 'postWireApi', {
-                        method: 'POST',
-                        url: `${BASE}/api/generate`,
-                        body: {
-                            prompt,
-                            platforms,
-                            media_url: mediaUrl || undefined,
-                            brand_voice: opts.brandVoice || undefined,
-                        },
-                        json: true,
-                    }));
+                let text;
+                if (contentMode === 'smart') {
+                    const gen = await GenericFunctions_1.generateDrafts.call(this, i, {
+                        prompt: this.getNodeParameter('prompt', i),
+                        platforms,
+                        media_url: mediaUrl || undefined,
+                        brand_voice: opts.brandVoice || undefined,
+                    });
                     perPlatform = gen.drafts;
-                    if (operation === 'generate') {
-                        out.push({ json: gen, pairedItem: { item: i } });
-                        continue;
+                }
+                else if (contentMode === 'drafts') {
+                    const raw = this.getNodeParameter('drafts', i);
+                    let parsed = raw;
+                    if (typeof raw === 'string') {
+                        try {
+                            parsed = JSON.parse(raw);
+                        }
+                        catch {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "'Drafts' is not valid JSON", {
+                                itemIndex: i,
+                                description: 'Map the output of Write Drafts with {{ $json.drafts }}, or write an object like { "x": { "text": "…" } }.',
+                            });
+                        }
                     }
+                    const obj = (parsed && typeof parsed === 'object' ? parsed : {});
+                    perPlatform = (obj.drafts && typeof obj.drafts === 'object' ? obj.drafts : obj);
+                    const missingDraft = platforms.filter((p) => { var _a; return !((_a = perPlatform === null || perPlatform === void 0 ? void 0 : perPlatform[p]) === null || _a === void 0 ? void 0 : _a.text); });
+                    if (missingDraft.length && !mediaUrl)
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `No draft for ${missingDraft.map(GenericFunctions_1.nameOf).join(', ')}`, {
+                            itemIndex: i,
+                            description: `'Drafts' needs a { "text": … } entry for every network in 'Networks'. Remove those networks or write drafts for them.`,
+                        });
+                }
+                else {
+                    text = this.getNodeParameter('text', i, '');
                 }
+                const brandId = locatorValue((_b = opts.brand) !== null && _b !== void 0 ? _b : opts.brandId);
                 const body = {
                     platforms,
                     per_platform: perPlatform,
-                    text: perPlatform ? undefined : this.getNodeParameter('text', i, ''),
-                    photo_url: photoUrl,
-                    video_url: videoUrl,
+                    text: perPlatform ? undefined : text,
+                    photo_url: mediaUrl && !treatAsVideo ? mediaUrl : undefined,
+                    video_url: mediaUrl && treatAsVideo ? mediaUrl : undefined,
                     title: opts.title || undefined,
                     privacy: opts.privacy || undefined,
-                    brand_id: opts.brandId || undefined,
+                    subreddit: opts.subreddit || undefined,
+                    brand_id: brandId || undefined,
                 };
                 if (operation === 'schedule') {
                     const runAt = this.getNodeParameter('runAt', i);
-                    const scheduled = (await this.helpers.httpRequestWithAuthentication.call(this, 'postWireApi', {
-                        method: 'POST',
-                        url: `${BASE}/api/schedule`,
-                        body: { ...body, run_at: runAt },
-                        json: true,
-                    }));
-                    out.push({ json: scheduled, pairedItem: { item: i } });
+                    if (!runAt)
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), "'Publish At' is empty", {
+                            itemIndex: i,
+                            description: 'Pick a date and time, or map one with an expression such as {{ $json.publish_at }}.',
+                        });
+                    const scheduled = await GenericFunctions_1.apiRequest.call(this, 'POST', '/api/schedule', {
+                        ...body,
+                        run_at: new Date(runAt).toISOString(),
+                        label: opts.label || undefined,
+                    }, undefined, i);
+                    push({ ...(scheduled.scheduled || scheduled), drafts: perPlatform });
                     continue;
                 }
-                const response = (await this.helpers.httpRequestWithAuthentication.call(this, 'postWireApi', {
-                    method: 'POST',
-                    url: `${BASE}/api/post`,
-                    body,
-                    json: true,
-                }));
-                // One n8n item per network, so a Filter or IF node downstream can act on the failures
-                // alone instead of unpacking an array by hand.
+                if (opts.dryRun) {
+                    const me = await GenericFunctions_1.apiRequest.call(this, 'GET', '/api/me', undefined, undefined, i);
+                    const conns = (me.connections || []).filter((c) => !brandId || c.brand_id === brandId);
+                    for (const p of platforms) {
+                        const draft = (perPlatform === null || perPlatform === void 0 ? void 0 : perPlatform[p]) || {};
+                        const t = String((_d = (_c = draft.text) !== null && _c !== void 0 ? _c : text) !== null && _d !== void 0 ? _d : '');
+                        const issues = [];
+                        if (!conns.some((c) => c.platform === p))
+                            issues.push(`${(0, GenericFunctions_1.nameOf)(p)} is not connected${brandId ? ' to this brand' : ''}`);
+                        const max = (0, GenericFunctions_1.maxOf)(p);
+                        if (max && t.length > max)
+                            issues.push(perPlatform
+                                ? `${t.length} characters, over the ${max} limit`
+                                : `${t.length} characters; PostWire will shorten it to ${max}`);
+                        if (!t.trim() && !mediaUrl)
+                            issues.push('no text');
+                        push({
+                            dryRun: true,
+                            platform: p,
+                            ready: !issues.some((s) => !s.includes('will shorten')),
+                            text: t,
+                            title: (_e = draft.title) !== null && _e !== void 0 ? _e : body.title,
+                            tags: draft.tags,
+                            media_url: mediaUrl || undefined,
+                            issues,
+                        });
+                    }
+                    continue;
+                }
+                let idem = String(opts.idempotencyKey || '').trim();
+                if (!idem && contentMode === 'smart') {
+                    const exec = (_f = this.getExecutionId) === null || _f === void 0 ? void 0 : _f.call(this);
+                    if (exec)
+                        idem = `n8n:${exec}:${this.getNode().name}:${i}`;
+                }
+                if (idem)
+                    body.idempotency_key = idem.slice(0, 200);
+                const response = await GenericFunctions_1.apiRequest.call(this, 'POST', '/api/post', body, undefined, i);
                 const results = (response.results || [response]).filter(Boolean);
                 for (const res of results) {
-                    out.push({ json: res, pairedItem: { item: i } });
+                    const extra = {};
+                    if (res.ok === false) {
+                        const hint = (0, GenericFunctions_1.hintFor)(res.platform, String(res.error || ''), res.code);
+                        if (hint)
+                            extra.hint = hint;
+                    }
+                    if (response.notice)
+                        extra.notice = response.notice;
+                    push({ ...res, ...extra });
                 }
-                // A 200 whose every network failed used to leave the node green with the error buried
-                // in the output, so a scheduled flow could publish nothing for weeks and never say so.
-                // If not one network went out, that is a failed execution.
-                const failed = results.filter((res) => res?.ok === false);
+                const failed = results.filter((res) => (res === null || res === void 0 ? void 0 : res.ok) === false);
                 if (results.length && failed.length === results.length) {
                     const why = failed
-                        .map((f) => `${f.platform || '?'}: ${f.error || f.code || 'failed'}`)
+                        .map((f) => `${(0, GenericFunctions_1.nameOf)(f.platform || '?')}: ${f.error || f.code || 'failed'}`)
                         .join('; ');
-                    const limited = failed.find((f) => f.code === 'brand_limit_reached' || f.upgrade_url);
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `PostWire published to none of the ${results.length} selected network(s). ${why}` +
-                        (limited?.upgrade_url ? ` — upgrade: ${limited.upgrade_url}` : ''), { itemIndex: i });
+                    const first = failed[0];
+                    const fix = (0, GenericFunctions_1.hintFor)(first.platform, String(first.error || ''), first.code) ||
+                        (0, GenericFunctions_1.describeFailure)(first.code, first).description;
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `PostWire published to none of the ${results.length} selected network(s)`, { itemIndex: i, description: `${why}${fix ? ` — ${fix}` : ''}` });
                 }
             }
             catch (error) {
                 if (this.continueOnFail()) {
-                    out.push({ json: { error: error.message }, pairedItem: { item: i } });
+                    out.push({
+                        json: {
+                            error: error.message,
+                            description: (_g = error.description) !== null && _g !== void 0 ? _g : undefined,
+                        },
+                        pairedItem: { item: i },
+                    });
                     continue;
                 }
-                // Our own checks already throw NodeOperationError with a message that names the fix;
-                // re-wrapping those would bury it. Anything else is an HTTP failure, and n8n renders
-                // a NodeApiError with the node's context instead of a bare fetch stack.
-                if (error instanceof n8n_workflow_1.NodeOperationError) {
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), error.message, { itemIndex: i });
-                }
-                throw new n8n_workflow_1.NodeApiError(this.getNode(), error, { itemIndex: i });
+                const e = error;
+                if (error instanceof n8n_workflow_1.NodeApiError)
+                    throw new n8n_workflow_1.NodeApiError(this.getNode(), {}, {
+                        message: e.message,
+                        description: (_h = e.description) !== null && _h !== void 0 ? _h : undefined,
+                        httpCode: (_j = e.httpCode) !== null && _j !== void 0 ? _j : undefined,
+                        itemIndex: i,
+                    });
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error.message, {
+                    itemIndex: i,
+                    description: (_k = error.description) !== null && _k !== void 0 ? _k : undefined,
+                });
             }
         }
         return [out];
     }
 }
 exports.PostWire = PostWire;
+//# sourceMappingURL=PostWire.node.js.map