posterly-mcp-server 0.8.3 → 0.19.0

package/dist/tools/reply-google-business-review.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const replyGoogleBusinessReviewTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        workspace_id: z.ZodOptional<z.ZodString>;
+        account_id: z.ZodOptional<z.ZodNumber>;
+        location_id: z.ZodOptional<z.ZodString>;
+        review_name: z.ZodString;
+        comment: z.ZodString;
+        confirm: z.ZodLiteral<true>;
+    }, "strip", z.ZodTypeAny, {
+        confirm: true;
+        review_name: string;
+        comment: string;
+        workspace_id?: string | undefined;
+        account_id?: number | undefined;
+        location_id?: string | undefined;
+    }, {
+        confirm: true;
+        review_name: string;
+        comment: string;
+        workspace_id?: string | undefined;
+        account_id?: number | undefined;
+        location_id?: string | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        workspace_id?: string;
+        account_id?: number;
+        location_id?: string;
+        review_name: string;
+        comment: string;
+        confirm: true;
+    }): Promise<any>;
+};

package/dist/tools/reply-google-business-review.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export const replyGoogleBusinessReviewTool = {
+    name: 'reply_google_business_review',
+    description: 'Post or update the owner reply on a Google Business Profile review. WRITE: show the review, location, and exact reply text to the user, then pass confirm=true only after explicit confirmation.',
+    inputSchema: z.object({
+        workspace_id: z.string().optional().describe('Filter to a workspace ID from whoami.'),
+        account_id: z.number().int().positive().optional().describe('Google Business account ID from list_accounts.'),
+        location_id: z.string().optional().describe('Google Business location/platform_user_id.'),
+        review_name: z.string().min(1).describe('Full Google review resource name.'),
+        comment: z.string().min(1).max(4096).describe('Exact owner reply text to post.'),
+        confirm: z.literal(true).describe('Must be true after explicit user confirmation.'),
+    }),
+    async execute(client, input) {
+        const { confirm: _confirm, ...payload } = input;
+        const result = await client.replyGoogleBusinessReview(payload);
+        return result.message || 'Google Business review reply posted successfully.';
+    },
+};

package/dist/tools/run-video-function.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const runVideoFunctionTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        identifier: z.ZodEnum<["google_veo", "veo3"]>;
+        functionName: z.ZodEnum<["list_input_modes", "estimate_cost", "validate_request"]>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        identifier: "google_veo" | "veo3";
+        functionName: "list_input_modes" | "estimate_cost" | "validate_request";
+        params?: Record<string, unknown> | undefined;
+    }, {
+        identifier: "google_veo" | "veo3";
+        functionName: "list_input_modes" | "estimate_cost" | "validate_request";
+        params?: Record<string, unknown> | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        identifier: string;
+        functionName: string;
+        params?: Record<string, unknown>;
+    }): Promise<string>;
+};

package/dist/tools/run-video-function.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export const runVideoFunctionTool = {
+    name: 'run_video_function',
+    description: 'Run a read-only Veo helper function before generation: list_input_modes, estimate_cost, or validate_request. This does not generate video or spend credits.',
+    inputSchema: z.object({
+        identifier: z
+            .enum(['google_veo', 'veo3'])
+            .describe('Video generator identifier from get_video_options.'),
+        functionName: z
+            .enum(['list_input_modes', 'estimate_cost', 'validate_request'])
+            .describe('Helper function name from get_video_options.tools.'),
+        params: z
+            .record(z.unknown())
+            .optional()
+            .describe('Function parameters. estimate_cost accepts model, duration_seconds, resolution, and output. validate_request accepts a generate_video-style payload.'),
+    }),
+    async execute(client, input) {
+        const result = await client.runVideoFunction(input);
+        return [
+            `Video function ${input.functionName} completed`,
+            '',
+            JSON.stringify(result, null, 2),
+        ].join('\n');
+    },
+};

package/dist/tools/suggest-google-business-review-reply.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const suggestGoogleBusinessReviewReplyTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        workspace_id: z.ZodOptional<z.ZodString>;
+        account_id: z.ZodOptional<z.ZodNumber>;
+        location_id: z.ZodOptional<z.ZodString>;
+        review_text: z.ZodOptional<z.ZodString>;
+        star_rating: z.ZodNumber;
+        reviewer_name: z.ZodOptional<z.ZodString>;
+        business_name: z.ZodOptional<z.ZodString>;
+        tone: z.ZodOptional<z.ZodEnum<["professional", "friendly", "apologetic"]>>;
+        count: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        star_rating: number;
+        workspace_id?: string | undefined;
+        account_id?: number | undefined;
+        count?: number | undefined;
+        location_id?: string | undefined;
+        review_text?: string | undefined;
+        reviewer_name?: string | undefined;
+        business_name?: string | undefined;
+        tone?: "professional" | "friendly" | "apologetic" | undefined;
+    }, {
+        star_rating: number;
+        workspace_id?: string | undefined;
+        account_id?: number | undefined;
+        count?: number | undefined;
+        location_id?: string | undefined;
+        review_text?: string | undefined;
+        reviewer_name?: string | undefined;
+        business_name?: string | undefined;
+        tone?: "professional" | "friendly" | "apologetic" | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        workspace_id?: string;
+        account_id?: number;
+        location_id?: string;
+        review_text?: string;
+        star_rating: number;
+        reviewer_name?: string;
+        business_name?: string;
+        tone?: "professional" | "friendly" | "apologetic";
+        count?: number;
+    }): Promise<string>;
+};

package/dist/tools/suggest-google-business-review-reply.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export const suggestGoogleBusinessReviewReplyTool = {
+    name: 'suggest_google_business_review_reply',
+    description: 'Generate short, brand-aware AI reply suggestions for a Google review. Uses the AI Caption Assist allowance; does not post the reply.',
+    inputSchema: z.object({
+        workspace_id: z.string().optional().describe('Filter to a workspace ID from whoami.'),
+        account_id: z.number().int().positive().optional().describe('Optional Google Business account ID for brand voice context.'),
+        location_id: z.string().optional().describe('Google Business location/platform_user_id.'),
+        review_text: z.string().optional().describe('Review text. Leave empty for rating-only reviews.'),
+        star_rating: z.number().min(1).max(5).describe('Review rating from 1 to 5.'),
+        reviewer_name: z.string().optional(),
+        business_name: z.string().optional(),
+        tone: z.enum(['professional', 'friendly', 'apologetic']).optional(),
+        count: z.number().int().min(1).max(5).optional(),
+    }),
+    async execute(client, input) {
+        const result = await client.suggestGoogleBusinessReviewReply(input);
+        const suggestions = Array.isArray(result.suggestions) ? result.suggestions : [];
+        if (suggestions.length === 0) {
+            return 'No reply suggestions were generated.';
+        }
+        return [
+            `Suggested replies (${result.tone || 'professional'}, ${result.rating || input.star_rating} stars):`,
+            ...suggestions.map((text, index) => `${index + 1}. ${text}`),
+        ].join('\n');
+    },
+};

package/dist/tools/test-webhook.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const testWebhookTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        webhook_id: z.ZodString;
+        confirm: z.ZodLiteral<true>;
+    }, "strip", z.ZodTypeAny, {
+        confirm: true;
+        webhook_id: string;
+    }, {
+        confirm: true;
+        webhook_id: string;
+    }>;
+    execute(client: PosterlyClient, input: {
+        webhook_id: string;
+        confirm: true;
+    }): Promise<string>;
+};

package/dist/tools/test-webhook.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+export const testWebhookTool = {
+    name: 'test_webhook',
+    description: 'Send a signed webhook.test delivery to a webhook URL. OUTBOUND SIDE EFFECT: get explicit confirmation before sending a test request.',
+    inputSchema: z.object({
+        webhook_id: z.string().describe('Webhook ID from list_webhooks.'),
+        confirm: z.literal(true).describe('Must be true after the user explicitly confirms the test delivery.'),
+    }),
+    async execute(client, input) {
+        const result = await client.testWebhook(input.webhook_id);
+        const delivery = result.delivery || {};
+        return `Webhook test sent.\nDelivery: ${JSON.stringify(delivery, null, 2)}`;
+    },
+};

package/dist/tools/trigger-platform-helper.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const triggerPlatformHelperTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        helper: z.ZodEnum<["linkedin.recent_mentions", "pinterest.boards", "tiktok.creator_info", "x.quota", "youtube.playlists"]>;
+        account_id: z.ZodOptional<z.ZodString>;
+        platform: z.ZodOptional<z.ZodEnum<["bluesky", "facebook", "gmb", "google-business", "google_business", "google_business_profile", "instagram", "instagram-standalone", "linkedin", "pinterest", "telegram", "threads", "tiktok", "twitter", "x", "youtube"]>>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        helper: "linkedin.recent_mentions" | "pinterest.boards" | "tiktok.creator_info" | "x.quota" | "youtube.playlists";
+        platform?: "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "linkedin" | "youtube" | "pinterest" | "threads" | "google_business" | "telegram" | "bluesky" | "gmb" | "google-business" | "google_business_profile" | "x" | undefined;
+        account_id?: string | undefined;
+        params?: Record<string, unknown> | undefined;
+    }, {
+        helper: "linkedin.recent_mentions" | "pinterest.boards" | "tiktok.creator_info" | "x.quota" | "youtube.playlists";
+        platform?: "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "linkedin" | "youtube" | "pinterest" | "threads" | "google_business" | "telegram" | "bluesky" | "gmb" | "google-business" | "google_business_profile" | "x" | undefined;
+        account_id?: string | undefined;
+        params?: Record<string, unknown> | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        helper: string;
+        account_id?: string;
+        platform?: string;
+        params?: Record<string, unknown>;
+    }): Promise<string>;
+};

package/dist/tools/trigger-platform-helper.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { PLATFORM_HELPER_NAMES, SUPPORTED_PLATFORM_INPUTS, SUPPORTED_PLATFORM_IDS } from '../generated/platform-manifest.js';
+export const triggerPlatformHelperTool = {
+    name: 'trigger_platform_helper',
+    description: `Run account-specific platform helper discovery. Available helpers: ${PLATFORM_HELPER_NAMES.join(', ')}.`,
+    inputSchema: z.object({
+        helper: z.enum(PLATFORM_HELPER_NAMES),
+        account_id: z
+            .string()
+            .optional()
+            .describe('Connected social account ID when the helper needs account context.'),
+        platform: z
+            .enum(SUPPORTED_PLATFORM_INPUTS)
+            .optional()
+            .describe(`Platform hint when no account_id is supplied. Supported: ${SUPPORTED_PLATFORM_IDS.join(', ')}.`),
+        params: z.record(z.unknown()).optional(),
+    }),
+    async execute(client, input) {
+        const result = await client.triggerPlatformHelper(input);
+        return JSON.stringify(result, null, 2);
+    },
+};

package/dist/tools/update-oauth-client.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const updateOAuthClientTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        client_id: z.ZodString;
+        client_name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        homepage: z.ZodOptional<z.ZodString>;
+        allowed_redirect_uris: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        default_scopes: z.ZodOptional<z.ZodArray<z.ZodEnum<["accounts:read", "accounts:write", "posts:read", "posts:write", "media:write", "analytics:read"]>, "many">>;
+        is_active: z.ZodOptional<z.ZodBoolean>;
+        confirm: z.ZodLiteral<true>;
+    }, "strip", z.ZodTypeAny, {
+        confirm: true;
+        client_id: string;
+        description?: string | undefined;
+        is_active?: boolean | undefined;
+        client_name?: string | undefined;
+        homepage?: string | undefined;
+        allowed_redirect_uris?: string[] | undefined;
+        default_scopes?: ("accounts:read" | "accounts:write" | "posts:read" | "posts:write" | "media:write" | "analytics:read")[] | undefined;
+    }, {
+        confirm: true;
+        client_id: string;
+        description?: string | undefined;
+        is_active?: boolean | undefined;
+        client_name?: string | undefined;
+        homepage?: string | undefined;
+        allowed_redirect_uris?: string[] | undefined;
+        default_scopes?: ("accounts:read" | "accounts:write" | "posts:read" | "posts:write" | "media:write" | "analytics:read")[] | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        client_id: string;
+        client_name?: string;
+        description?: string;
+        homepage?: string;
+        allowed_redirect_uris?: string[];
+        default_scopes?: string[];
+        is_active?: boolean;
+        confirm: true;
+    }): Promise<string>;
+};

package/dist/tools/update-oauth-client.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+const scopeSchema = z.enum(['accounts:read', 'accounts:write', 'posts:read', 'posts:write', 'media:write', 'analytics:read']);
+export const updateOAuthClientTool = {
+    name: 'update_oauth_client',
+    description: 'Update a self-serve OAuth developer client. WRITE: confirm changed redirect URIs, scopes, and active state before calling.',
+    inputSchema: z.object({
+        client_id: z.string().min(1),
+        client_name: z.string().min(1).max(120).optional(),
+        description: z.string().max(500).optional(),
+        homepage: z.string().url().optional(),
+        allowed_redirect_uris: z.array(z.string().url()).min(1).max(10).optional(),
+        default_scopes: z.array(scopeSchema).min(1).optional(),
+        is_active: z.boolean().optional(),
+        confirm: z.literal(true).describe('Must be true after explicit user confirmation.'),
+    }),
+    async execute(client, input) {
+        const { client_id, confirm: _confirm, ...payload } = input;
+        const result = await client.updateOAuthClient(client_id, payload);
+        return `OAuth client updated: ${result.client.client_name} (${result.client.client_id}) active=${result.client.is_active}`;
+    },
+};

package/dist/tools/update-post-release-id.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const updatePostReleaseIdTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        post_id: z.ZodNumber;
+        release_id: z.ZodString;
+        group_id: z.ZodOptional<z.ZodString>;
+        confirm: z.ZodLiteral<true>;
+    }, "strip", z.ZodTypeAny, {
+        post_id: number;
+        confirm: true;
+        release_id: string;
+        group_id?: string | undefined;
+    }, {
+        post_id: number;
+        confirm: true;
+        release_id: string;
+        group_id?: string | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        post_id: number;
+        release_id: string;
+        group_id?: string;
+        confirm: true;
+    }): Promise<string>;
+};

package/dist/tools/update-post-release-id.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export const updatePostReleaseIdTool = {
+    name: 'update_post_release_id',
+    description: 'Set or repair an external release_id and optional group_id on a post. WRITE: call get_post first, show the target post and release/group IDs, then pass confirm=true only after explicit confirmation.',
+    inputSchema: z.object({
+        post_id: z.number().int().positive().describe('The post ID to update.'),
+        release_id: z.string().min(1).max(160).describe('External release ID to store on the post.'),
+        group_id: z.string().min(1).max(160).optional().describe('Optional external group/campaign ID.'),
+        confirm: z.literal(true).describe('Must be true after explicit user confirmation.'),
+    }),
+    async execute(client, input) {
+        const result = await client.updatePostReleaseId(input.post_id, {
+            release_id: input.release_id,
+            group_id: input.group_id,
+        });
+        return JSON.stringify(result, null, 2);
+    },
+};

package/dist/tools/update-post-status.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const updatePostStatusTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        post_id: z.ZodNumber;
+        status: z.ZodEnum<["scheduled", "paused", "draft"]>;
+        scheduled_at: z.ZodOptional<z.ZodString>;
+        confirm: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        status: "scheduled" | "paused" | "draft";
+        post_id: number;
+        confirm: boolean;
+        scheduled_at?: string | undefined;
+    }, {
+        status: "scheduled" | "paused" | "draft";
+        post_id: number;
+        confirm: boolean;
+        scheduled_at?: string | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        post_id: number;
+        status: "scheduled" | "paused" | "draft";
+        scheduled_at?: string;
+        confirm: boolean;
+    }): Promise<string>;
+};

package/dist/tools/update-post-status.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export const updatePostStatusTool = {
+    name: 'update_post_status',
+    description: 'Pause, resume/schedule, or move a post back to draft. DESTRUCTIVE WRITE: changes whether content will publish.\n\n' +
+        'REQUIRED BEFORE CALLING: Fetch the post with `get_post`, show the user current status and proposed status/scheduled_at, then get explicit confirmation. Pass confirm=true only after that confirmation.',
+    inputSchema: z.object({
+        post_id: z.number().describe('The post ID to update.'),
+        status: z.enum(['scheduled', 'paused', 'draft']).describe('Target status.'),
+        scheduled_at: z.string().optional().describe('ISO 8601 datetime. Required when scheduling a draft.'),
+        confirm: z.boolean().describe('Must be true after explicit user confirmation.'),
+    }),
+    async execute(client, input) {
+        if (input.confirm !== true) {
+            throw new Error('Refusing to update post status without confirm=true after explicit user confirmation.');
+        }
+        const result = await client.updatePostStatus(input.post_id, {
+            status: input.status,
+            scheduled_at: input.scheduled_at,
+        });
+        const transition = result.transition || {};
+        return `Post #${input.post_id} status changed from ${transition.old_status || 'unknown'} to ${transition.new_status || input.status}.`;
+    },
+};

package/dist/tools/update-post.js

@@ -74,7 +74,7 @@ export const updatePostTool = {
             .describe('New post type: text, image, video, carousel, reel, story'),
         instagram_settings: instagramSettingsSchema
             .optional()
-            .describe('Instagram-specific updates: post_type, collaborators, user_tags, first_comment, media_alt_texts, is_trial_reel, graduation_strategy, reel_cover_url, reel_thumb_offset.'),
+            .describe('Instagram-specific updates: post_type, collaborators, user_tags, first_comment, media_alt_texts, is_trial_reel, graduation_strategy (defaults to MANUAL), reel_cover_url, reel_thumb_offset.'),
         platform_settings: platformSettingsSchema
             .optional()
             .describe('Platform-specific settings to merge into the post. Prefer this over raw metadata.'),

package/dist/tools/update-webhook.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const updateWebhookTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        webhook_id: z.ZodString;
+        url: z.ZodOptional<z.ZodString>;
+        events: z.ZodOptional<z.ZodArray<z.ZodEnum<["webhook.test", "post.created", "post.updated", "post.deleted", "post.publishing", "post.published", "post.failed", "account.disconnected", "analytics.synced"]>, "many">>;
+        workspace_id: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+        description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+        is_active: z.ZodOptional<z.ZodBoolean>;
+        confirm: z.ZodLiteral<true>;
+    }, "strip", z.ZodTypeAny, {
+        confirm: true;
+        webhook_id: string;
+        workspace_id?: string | null | undefined;
+        url?: string | undefined;
+        events?: ("webhook.test" | "post.created" | "post.updated" | "post.deleted" | "post.publishing" | "post.published" | "post.failed" | "account.disconnected" | "analytics.synced")[] | undefined;
+        description?: string | null | undefined;
+        is_active?: boolean | undefined;
+    }, {
+        confirm: true;
+        webhook_id: string;
+        workspace_id?: string | null | undefined;
+        url?: string | undefined;
+        events?: ("webhook.test" | "post.created" | "post.updated" | "post.deleted" | "post.publishing" | "post.published" | "post.failed" | "account.disconnected" | "analytics.synced")[] | undefined;
+        description?: string | null | undefined;
+        is_active?: boolean | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        webhook_id: string;
+        url?: string;
+        events?: string[];
+        workspace_id?: string | null;
+        description?: string | null;
+        is_active?: boolean;
+        confirm: true;
+    }): Promise<string>;
+};

package/dist/tools/update-webhook.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { webhookEventSchema } from './webhook-events.js';
+export const updateWebhookTool = {
+    name: 'update_webhook',
+    description: 'Update a webhook URL, events, workspace, description, or active state. WRITE WITH OUTBOUND SIDE EFFECTS: list the current webhook first and get explicit confirmation before calling.',
+    inputSchema: z.object({
+        webhook_id: z.string().describe('Webhook ID from list_webhooks.'),
+        url: z.string().url().optional(),
+        events: z.array(webhookEventSchema).optional(),
+        workspace_id: z.union([z.string(), z.null()]).optional(),
+        description: z.union([z.string().max(240), z.null()]).optional(),
+        is_active: z.boolean().optional(),
+        confirm: z.literal(true).describe('Must be true after the user explicitly confirms the webhook update.'),
+    }),
+    async execute(client, input) {
+        const { webhook_id, confirm: _confirm, ...payload } = input;
+        const result = await client.updateWebhook(webhook_id, payload);
+        const active = result.webhook.is_active ? 'active' : 'inactive';
+        return `Webhook updated: ${result.webhook.id}\nURL: ${result.webhook.url}\nState: ${active}\nEvents: ${result.webhook.events.join(', ')}`;
+    },
+};

package/dist/tools/upload-media-from-url.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const uploadMediaFromUrlTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        url: z.ZodString;
+        filename: z.ZodOptional<z.ZodString>;
+        content_type: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        content_type?: string | undefined;
+        filename?: string | undefined;
+    }, {
+        url: string;
+        content_type?: string | undefined;
+        filename?: string | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        url: string;
+        filename?: string;
+        content_type?: string;
+    }): Promise<string>;
+};

package/dist/tools/upload-media-from-url.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export const uploadMediaFromUrlTool = {
+    name: 'upload_media_from_url',
+    description: 'Fetch an image or video from a public HTTPS URL into posterly storage. Returns a URL that can be used with create_post.',
+    inputSchema: z.object({
+        url: z.string().url().describe('Public HTTPS URL for the image or video. Local/private network URLs are blocked.'),
+        filename: z.string().optional().describe('Optional filename override.'),
+        content_type: z.string().optional().describe('Optional MIME type override.'),
+    }),
+    async execute(client, input) {
+        const result = await client.uploadMediaFromUrl({
+            url: input.url,
+            filename: input.filename,
+            contentType: input.content_type,
+        });
+        return [
+            'Remote media uploaded successfully.',
+            `• URL: ${result.url}`,
+            `• Source URL: ${result.source_url}`,
+            `• Content type: ${result.content_type}`,
+            `• Size: ${result.size} bytes`,
+            '',
+            'Use this URL as media_url when creating a post.',
+        ].join('\n');
+    },
+};

package/dist/tools/webhook-events.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export declare const WEBHOOK_EVENTS: readonly ["webhook.test", "post.created", "post.updated", "post.deleted", "post.publishing", "post.published", "post.failed", "account.disconnected", "analytics.synced"];
+export declare const webhookEventSchema: z.ZodEnum<["webhook.test", "post.created", "post.updated", "post.deleted", "post.publishing", "post.published", "post.failed", "account.disconnected", "analytics.synced"]>;

package/dist/tools/webhook-events.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export const WEBHOOK_EVENTS = [
+    'webhook.test',
+    'post.created',
+    'post.updated',
+    'post.deleted',
+    'post.publishing',
+    'post.published',
+    'post.failed',
+    'account.disconnected',
+    'analytics.synced',
+];
+export const webhookEventSchema = z.enum(WEBHOOK_EVENTS);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "posterly-mcp-server",
-  "version": "0.8.3",
+  "version": "0.19.0",
   "description": "MCP server for posterly — schedule social media posts from Claude Desktop",
   "license": "MIT",
   "homepage": "https://www.poster.ly/mcp",