posterly-mcp-server 0.8.3 → 0.19.0

package/dist/tools/get-connect-link.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { CONNECT_INPUTS, PLANNED_PLATFORM_IDS } from '../generated/platform-manifest.js';
+export const getConnectLinkTool = {
+    name: 'get_connect_link',
+    description: 'List dashboard handoff links/readiness for connecting social accounts, or get one platform connection URL. Use connection_url in a logged-in browser. Direct OAuth URLs are intentionally not exposed because provider callbacks rely on browser state.',
+    inputSchema: z.object({
+        platform: z
+            .enum(CONNECT_INPUTS)
+            .optional()
+            .describe('Connection target such as instagram, meta, linkedin_page, twitter, x, google_business, telegram, reddit, or wordpress. Omit to list live connection targets.'),
+        workspace_id: z
+            .string()
+            .optional()
+            .describe('Filter connected account counts to a workspace.'),
+        include_planned: z
+            .boolean()
+            .optional()
+            .describe(`Include planned provider expansion targets from the Postiz parity audit: ${PLANNED_PLATFORM_IDS.join(', ')}.`),
+    }),
+    async execute(client, input) {
+        const result = await client.getConnectLink(input);
+        if (result.connect) {
+            return formatConnectOption(result.connect, true);
+        }
+        const options = result.connect_options || [];
+        const lines = options.map((option) => formatConnectOption(option, false));
+        return `Posterly connection options (${options.length}):\n${lines.join('\n\n')}`;
+    },
+};
+function formatConnectOption(option, includeRaw) {
+    const missing = option.missing_env?.length
+        ? `missing env: ${option.missing_env.map((group) => group.join(' or ')).join(', ')}`
+        : 'configured';
+    const accounts = option.connected_count ?? option.connected_accounts?.length ?? 0;
+    const fields = option.credential_fields?.length
+        ? `; credential fields: ${option.credential_fields.map((field) => field.key).join(', ')}`
+        : '';
+    const scopes = option.scopes?.length ? `; scopes: ${option.scopes.join(', ')}` : '';
+    const raw = includeRaw ? `\n\nRaw connect option:\n${JSON.stringify(option, null, 2)}` : '';
+    return [
+        `${option.label} (${option.platform})`,
+        `Status: ${option.status}; method: ${option.method}; ${missing}; connected accounts: ${accounts}`,
+        `Connection URL: ${option.connection_url || 'not available'}${fields}${scopes}`,
+        raw,
+    ].join('\n');
+}

package/dist/tools/get-google-business-review-link.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const getGoogleBusinessReviewLinkTool: {
+    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>;
+    }, "strip", z.ZodTypeAny, {
+        workspace_id?: string | undefined;
+        account_id?: number | undefined;
+        location_id?: string | undefined;
+    }, {
+        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;
+    }): Promise<string>;
+};

package/dist/tools/get-google-business-review-link.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export const getGoogleBusinessReviewLinkTool = {
+    name: 'get_google_business_review_link',
+    description: 'Get the direct public Google review link for a connected Google Business Profile location. Requires account_id or location_id.',
+    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.'),
+    }),
+    async execute(client, input) {
+        const result = await client.getGoogleBusinessReviewLink(input);
+        return [
+            `Review link for ${result.businessName}:`,
+            result.reviewLink,
+            `Place ID: ${result.placeId}`,
+            `Account ID: ${result.account_id}`,
+        ].join('\n');
+    },
+};

package/dist/tools/get-platform-schema.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const getPlatformSchemaTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        account_id: z.ZodOptional<z.ZodString>;
+        platform: z.ZodOptional<z.ZodEnum<["bluesky", "devto", "discord", "facebook", "gmb", "google-business", "google_business", "google_business_profile", "hashnode", "instagram", "instagram-standalone", "linkedin", "mastodon", "medium", "pinterest", "reddit", "skool", "slack", "telegram", "threads", "tiktok", "twitter", "whop", "wordpress", "x", "youtube"]>>;
+        include_planned: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        include_planned?: boolean | undefined;
+        platform?: "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "linkedin" | "youtube" | "pinterest" | "threads" | "google_business" | "telegram" | "bluesky" | "reddit" | "wordpress" | "mastodon" | "medium" | "devto" | "hashnode" | "discord" | "slack" | "skool" | "whop" | "gmb" | "google-business" | "google_business_profile" | "x" | undefined;
+        account_id?: string | undefined;
+    }, {
+        include_planned?: boolean | undefined;
+        platform?: "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "linkedin" | "youtube" | "pinterest" | "threads" | "google_business" | "telegram" | "bluesky" | "reddit" | "wordpress" | "mastodon" | "medium" | "devto" | "hashnode" | "discord" | "slack" | "skool" | "whop" | "gmb" | "google-business" | "google_business_profile" | "x" | undefined;
+        account_id?: string | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        account_id?: string;
+        platform?: string;
+        include_planned?: boolean;
+    }): Promise<string>;
+};

package/dist/tools/get-platform-schema.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { ALL_PLATFORM_INPUTS, SUPPORTED_PLATFORM_IDS } from '../generated/platform-manifest.js';
+export const getPlatformSchemaTool = {
+    name: 'get_platform_schema',
+    description: 'Get the platform schema for a specific connected account or platform. Call this before creating posts with platform_settings so you know allowed post types, media limits, helper tools, and field names.',
+    inputSchema: z.object({
+        account_id: z
+            .string()
+            .optional()
+            .describe('Connected account ID from list_accounts. Preferred because it returns account context.'),
+        platform: z
+            .enum(ALL_PLATFORM_INPUTS)
+            .optional()
+            .describe(`Platform ID such as ${SUPPORTED_PLATFORM_IDS.join(', ')}. Set include_planned to inspect planned providers.`),
+        include_planned: z.boolean().optional(),
+    }),
+    async execute(client, input) {
+        const result = await client.getPlatformSchema(input);
+        const schema = result.schema || result.platform || result.platforms?.[0];
+        if (!schema)
+            return JSON.stringify(result, null, 2);
+        const fields = schema.settings_schema?.fields || [];
+        const helpers = schema.helper_tools || [];
+        const accountLine = result.account
+            ? `Account: ${result.account.username || result.account.id} (${result.account.platform})\n`
+            : '';
+        return [
+            `${schema.label} (${schema.id}) schema`,
+            accountLine.trim(),
+            `Status: ${schema.status}`,
+            `Post types: ${schema.post_types.join(', ') || 'n/a'}`,
+            `Content limit: ${schema.content_limit ?? 'n/a'}`,
+            `Media: ${JSON.stringify(schema.media)}`,
+            `Analytics: ${schema.analytics_supported ? 'yes' : 'no'}`,
+            fields.length
+                ? `Settings:\n${fields.map((field) => `• ${field.key}${field.required ? ' (required)' : ''}: ${field.description}`).join('\n')}`
+                : 'Settings: none',
+            helpers.length
+                ? `Helpers:\n${helpers.map((helper) => `• ${helper.name}: ${helper.description}`).join('\n')}`
+                : 'Helpers: none',
+            `Example settings: ${JSON.stringify(schema.settings_schema?.example || {})}`,
+        ].filter(Boolean).join('\n');
+    },
+};

package/dist/tools/get-post-missing.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const getPostMissingTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        post_id: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        post_id: number;
+    }, {
+        post_id: number;
+    }>;
+    execute(client: PosterlyClient, input: {
+        post_id: number;
+    }): Promise<string>;
+};

package/dist/tools/get-post-missing.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export const getPostMissingTool = {
+    name: 'get_post_missing',
+    description: 'Inspect whether a post is missing required content, media, account, platform settings, or metadata before it can publish. Use this to repair failed or imported posts.',
+    inputSchema: z.object({
+        post_id: z.number().int().positive().describe('The post ID to inspect.'),
+    }),
+    async execute(client, input) {
+        const result = await client.getPostMissing(input.post_id);
+        return JSON.stringify(result, null, 2);
+    },
+};

package/dist/tools/get-video-job.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const getVideoJobTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        job_id: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodEnum<["pending", "processing", "completed", "failed", "dismissed"]>>;
+        limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        status?: "pending" | "processing" | "completed" | "failed" | "dismissed" | undefined;
+        limit?: number | undefined;
+        job_id?: string | undefined;
+    }, {
+        status?: "pending" | "processing" | "completed" | "failed" | "dismissed" | undefined;
+        limit?: number | undefined;
+        job_id?: string | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        job_id?: string;
+        status?: string;
+        limit?: number;
+    }): Promise<string>;
+};

package/dist/tools/get-video-job.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export const getVideoJobTool = {
+    name: 'get_video_job',
+    description: 'Get one Veo video generation job by ID, or list recent video jobs when job_id is omitted. Use after generate_video to poll for completed video_url.',
+    inputSchema: z.object({
+        job_id: z.string().optional(),
+        status: z.enum(['pending', 'processing', 'completed', 'failed', 'dismissed']).optional(),
+        limit: z.number().int().min(1).max(50).default(10).optional(),
+    }),
+    async execute(client, input) {
+        const result = await client.getVideoJob(input);
+        if (result.job)
+            return formatJob(result.job, true);
+        const jobs = result.jobs || [];
+        return [
+            `Video jobs (${jobs.length})`,
+            jobs.map((job) => formatJob(job, false)).join('\n\n'),
+        ].filter(Boolean).join('\n');
+    },
+};
+function formatJob(job, includeRaw) {
+    const lines = [
+        `${job.id} — ${job.status}`,
+        `Prompt: ${job.prompt}`,
+        `Model: ${job.model}; duration: ${job.duration_seconds}s; resolution: ${job.resolution || 'n/a'}; cost: ${job.credit_cost}`,
+        job.video_url ? `Video URL: ${job.video_url}` : null,
+        job.error_message ? `Error: ${job.error_message}` : null,
+        includeRaw ? `\nRaw job:\n${JSON.stringify(job, null, 2)}` : null,
+    ];
+    return lines.filter(Boolean).join('\n');
+}

package/dist/tools/get-video-options.d.ts

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

package/dist/tools/get-video-options.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export const getVideoOptionsTool = {
+    name: 'get_video_options',
+    description: 'List read-only Veo video generation options, input modes, durations, resolutions, aspect ratios, and credit-cost estimates. This does not generate video or spend credits.',
+    inputSchema: z.object({}),
+    async execute(client) {
+        const options = await client.getVideoOptions();
+        const models = Array.isArray(options.models) ? options.models : [];
+        const inputModes = Array.isArray(options.input_modes) ? options.input_modes : [];
+        const lines = [
+            'Video generation options',
+            `Provider: ${options.provider || 'unknown'}`,
+            `Public generation status: ${options.public_generation_status || 'unknown'}`,
+            '',
+            `Models: ${models.map((model) => model.id).filter(Boolean).join(', ') || 'none'}`,
+            `Durations: ${(options.durations_seconds || []).join(', ')} seconds`,
+            `Resolutions: ${(options.resolutions || []).join(', ')}`,
+            `Aspect ratios: ${(options.aspect_ratios || []).join(', ')}`,
+            `Input modes: ${inputModes.map((mode) => mode.id).filter(Boolean).join(', ') || 'none'}`,
+            '',
+            'Raw options:',
+            JSON.stringify(options, null, 2),
+        ];
+        return lines.join('\n');
+    },
+};

package/dist/tools/get-x-posting-quota.d.ts

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

package/dist/tools/get-x-posting-quota.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export const getXPostingQuotaTool = {
+    name: 'get_x_posting_quota',
+    description: 'Get managed X posting quota for a workspace, including total monthly allowance, used posts, remaining posts, and URL-blocking status.',
+    inputSchema: z.object({
+        workspace_id: z.string().optional().describe('Workspace ID from whoami. Defaults to the caller personal workspace context.'),
+    }),
+    async execute(client, input) {
+        const quota = await client.getXPostingQuota(input);
+        return [
+            'X posting quota',
+            `• Workspace: ${quota.workspace_id || 'default'}`,
+            `• Tier: ${quota.tier || 'unknown'}`,
+            `• Total posts: ${quota.total_posts}`,
+            `• Used posts: ${quota.used_posts}`,
+            `• Remaining posts: ${quota.remaining_posts}`,
+            `• URL posting blocked: ${quota.urls_blocked ? 'yes' : 'no'}`,
+            `• Period: ${quota.current_period_start} -> ${quota.current_period_end}`,
+        ].join('\n');
+    },
+};

package/dist/tools/list-activity.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const listActivityTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        workspace_id: z.ZodOptional<z.ZodString>;
+        post_id: z.ZodOptional<z.ZodNumber>;
+        since: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodEnum<["all", "activity", "publish"]>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        workspace_id?: string | undefined;
+        limit?: number | undefined;
+        post_id?: number | undefined;
+        since?: string | undefined;
+        type?: "activity" | "publish" | "all" | undefined;
+    }, {
+        workspace_id?: string | undefined;
+        limit?: number | undefined;
+        post_id?: number | undefined;
+        since?: string | undefined;
+        type?: "activity" | "publish" | "all" | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        workspace_id?: string;
+        post_id?: number;
+        since?: string;
+        type?: "all" | "activity" | "publish";
+        limit?: number;
+    }): Promise<string>;
+};

package/dist/tools/list-activity.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+export const listActivityTool = {
+    name: 'list_activity',
+    description: 'List recent activity and publish events for posts, including status changes, publish attempts, failures, and retries. Use this as the agent notifications feed.',
+    inputSchema: z.object({
+        workspace_id: z.string().optional().describe('Filter to a workspace ID from whoami.'),
+        post_id: z.number().int().positive().optional().describe('Filter to one post ID.'),
+        since: z.string().optional().describe('ISO datetime. Return events created at or after this time.'),
+        type: z.enum(['all', 'activity', 'publish']).optional().describe('Event source filter. Defaults to all.'),
+        limit: z.number().int().min(1).max(100).optional().describe('Number of items to return. Default 50, max 100.'),
+    }),
+    async execute(client, input) {
+        const result = await client.listActivity(input);
+        if (result.items.length === 0) {
+            return 'No activity found matching your filters.';
+        }
+        const lines = [
+            `Activity (${result.items.length} of ${result.total}):`,
+        ];
+        for (const item of result.items) {
+            const when = item.created_at ? new Date(item.created_at).toLocaleString() : 'unknown time';
+            if (item.type === 'publish') {
+                const outcome = item.outcome || 'publish';
+                const platform = item.platform ? ` on ${item.platform}` : '';
+                const detail = item.error_message ? ` - ${item.error_message}` : '';
+                lines.push(`- [${when}] post #${item.post_id || '?'} ${outcome}${platform}${detail}`);
+            }
+            else {
+                const label = item.description || item.action || 'activity';
+                lines.push(`- [${when}] post #${item.post_id || '?'} ${label}`);
+            }
+        }
+        return lines.join('\n');
+    },
+};

package/dist/tools/list-google-business-reviews.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const listGoogleBusinessReviewsTool: {
+    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>;
+        rating: z.ZodOptional<z.ZodNumber>;
+        unanswered: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        workspace_id?: string | undefined;
+        account_id?: number | undefined;
+        location_id?: string | undefined;
+        rating?: number | undefined;
+        unanswered?: boolean | undefined;
+    }, {
+        workspace_id?: string | undefined;
+        account_id?: number | undefined;
+        location_id?: string | undefined;
+        rating?: number | undefined;
+        unanswered?: boolean | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        workspace_id?: string;
+        account_id?: number;
+        location_id?: string;
+        rating?: number;
+        unanswered?: boolean;
+    }): Promise<string>;
+};

package/dist/tools/list-google-business-reviews.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export const listGoogleBusinessReviewsTool = {
+    name: 'list_google_business_reviews',
+    description: 'List Google Business Profile reviews for one location/account or every accessible GBP location. Supports rating and unanswered-only filters.',
+    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.'),
+        rating: z.number().int().min(1).max(5).optional().describe('Filter to a 1-5 star rating.'),
+        unanswered: z.boolean().optional().describe('Only return reviews without owner replies.'),
+    }),
+    async execute(client, input) {
+        const result = await client.listGoogleBusinessReviews(input);
+        if (result.reviews.length === 0) {
+            return 'No Google Business reviews found matching your filters.';
+        }
+        const lines = [`Google Business reviews (${result.reviews.length} of ${result.total}):`];
+        for (const review of result.reviews.slice(0, 25)) {
+            const name = review.reviewer?.displayName || 'Anonymous';
+            const rating = review.starRating ? `${review.starRating} stars` : 'unrated';
+            const location = review.businessName || review.locationName || review.locationId || 'location';
+            const text = review.comment ? ` - ${review.comment.replace(/\s+/g, ' ').slice(0, 180)}` : '';
+            const replied = review.reviewReply ? ' replied' : ' unanswered';
+            lines.push(`- ${name} (${rating}, ${location},${replied})${text}`);
+        }
+        return lines.join('\n');
+    },
+};

package/dist/tools/list-oauth-clients.d.ts

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

package/dist/tools/list-oauth-clients.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export const listOAuthClientsTool = {
+    name: 'list_oauth_clients',
+    description: 'List self-serve OAuth developer clients owned by the user. These are public PKCE clients for third-party app integrations.',
+    inputSchema: z.object({}),
+    async execute(client) {
+        const result = await client.listOAuthClients();
+        if (result.clients.length === 0)
+            return 'No OAuth developer clients found.';
+        return [
+            `OAuth developer clients (${result.clients.length}):`,
+            ...result.clients.map((item) => `- ${item.client_name} (${item.client_id}) scopes=${item.default_scopes.join(', ')} active=${item.is_active}`),
+        ].join('\n');
+    },
+};

package/dist/tools/list-platforms.d.ts

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

package/dist/tools/list-platforms.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { PLANNED_PLATFORM_IDS } from '../generated/platform-manifest.js';
+export const listPlatformsTool = {
+    name: 'list_platforms',
+    description: 'List posterly platform integrations, posting capabilities, content/media limits, settings schemas, helper tools, and analytics support. Use include_planned to show future integration possibilities from the Postiz parity audit.',
+    inputSchema: z.object({
+        include_planned: z
+            .boolean()
+            .optional()
+            .describe(`Include planned integrations such as ${PLANNED_PLATFORM_IDS.join(', ')}.`),
+    }),
+    async execute(client, input) {
+        const result = await client.listPlatforms(input);
+        const lines = result.platforms.map((platform) => {
+            const helperCount = platform.helper_tools?.length || 0;
+            return `• ${platform.label} (${platform.id}) — ${platform.status}; post types: ${platform.post_types.join(', ') || 'n/a'}; helpers: ${helperCount}; analytics: ${platform.analytics_supported ? 'yes' : 'no'}`;
+        });
+        return `Posterly platforms (${result.platforms.length}):\n${lines.join('\n')}`;
+    },
+};

package/dist/tools/list-posts.d.ts

@@ -5,20 +5,20 @@ export declare const listPostsTool: {
     description: string;
     inputSchema: z.ZodObject<{
         status: z.ZodOptional<z.ZodString>;
-        platform: 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"]>>;
         account_id: z.ZodOptional<z.ZodString>;
         limit: z.ZodOptional<z.ZodNumber>;
         workspace_id: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         workspace_id?: string | undefined;
+        platform?: "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "linkedin" | "youtube" | "pinterest" | "threads" | "google_business" | "telegram" | "bluesky" | "gmb" | "google-business" | "google_business_profile" | "x" | undefined;
         status?: string | undefined;
-        platform?: string | undefined;
         account_id?: string | undefined;
         limit?: number | undefined;
     }, {
         workspace_id?: string | undefined;
+        platform?: "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "linkedin" | "youtube" | "pinterest" | "threads" | "google_business" | "telegram" | "bluesky" | "gmb" | "google-business" | "google_business_profile" | "x" | undefined;
         status?: string | undefined;
-        platform?: string | undefined;
         account_id?: string | undefined;
         limit?: number | undefined;
     }>;

package/dist/tools/list-posts.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { SUPPORTED_PLATFORM_INPUTS, SUPPORTED_PLATFORM_IDS } from '../generated/platform-manifest.js';
 export const listPostsTool = {
     name: 'list_posts',
     description: 'List upcoming or recent posts. Filter by status (scheduled, published, failed, draft), platform, account_id, or workspace_id. If workspace_id is omitted, posts across every workspace the caller is a member of are returned.',
@@ -8,9 +9,9 @@ export const listPostsTool = {
             .optional()
             .describe('Filter by status: draft, scheduled, published, failed'),
         platform: z
-            .string()
+            .enum(SUPPORTED_PLATFORM_INPUTS)
             .optional()
-            .describe('Filter by platform: instagram, twitter, linkedin, etc.'),
+            .describe(`Filter by platform: ${SUPPORTED_PLATFORM_IDS.join(', ')}.`),
         account_id: z
             .string()
             .optional()

package/dist/tools/list-webhooks.d.ts

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

package/dist/tools/list-webhooks.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export const listWebhooksTool = {
+    name: 'list_webhooks',
+    description: 'List API webhook subscriptions, their event filters, active state, and most recent delivery status.',
+    inputSchema: z.object({
+        workspace_id: z.string().optional().describe('Filter to a workspace ID from whoami.'),
+    }),
+    async execute(client, input) {
+        const { webhooks } = await client.listWebhooks(input);
+        if (webhooks.length === 0) {
+            return 'No webhooks found.';
+        }
+        const lines = [`Webhooks (${webhooks.length}):`];
+        for (const webhook of webhooks) {
+            const active = webhook.is_active ? 'active' : 'inactive';
+            const events = webhook.events?.length ? webhook.events.join(', ') : 'default events';
+            const last = webhook.last_delivery_at
+                ? ` last ${webhook.last_delivery_status || 'n/a'} at ${new Date(webhook.last_delivery_at).toLocaleString()}`
+                : '';
+            lines.push(`- ${webhook.id} [${active}] ${webhook.url} (${events})${last}`);
+        }
+        return lines.join('\n');
+    },
+};