posterly-mcp-server 0.8.2 → 0.19.0

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.2",
+  "version": "0.19.0",
   "description": "MCP server for posterly — schedule social media posts from Claude Desktop",
   "license": "MIT",
   "homepage": "https://www.poster.ly/mcp",