posterly-mcp-server 0.8.3 → 0.19.0

package/dist/lib/api-client.d.ts

@@ -232,6 +232,163 @@ export interface PostAnalyticsResponse {
     limit: number;
     offset: number;
 }
+export interface GoogleBusinessReview {
+    name?: string;
+    reviewId?: string;
+    reviewer?: {
+        displayName?: string;
+        profilePhotoUrl?: string;
+    };
+    starRating: number;
+    comment?: string;
+    createTime?: string;
+    updateTime?: string;
+    reviewReply?: Record<string, unknown>;
+    locationId?: string | null;
+    locationName?: string | null;
+    businessName?: string | null;
+    socialAccountId?: number;
+    account_id?: number;
+}
+export interface GoogleBusinessReviewsResponse {
+    reviews: GoogleBusinessReview[];
+    total: number;
+    locations: Array<Record<string, unknown>>;
+}
+export interface GoogleBusinessReviewLinkResponse {
+    reviewLink: string;
+    placeId: string;
+    businessName: string;
+    locationId: string | null;
+    account_id: number;
+}
+export interface ActivityItem {
+    id: string;
+    type: 'activity' | 'publish';
+    post_id: number | null;
+    action?: string | null;
+    description?: string | null;
+    platform?: string | null;
+    outcome?: string | null;
+    error_code?: string | null;
+    error_message?: string | null;
+    http_status?: number | null;
+    retry_number?: number | null;
+    duration_ms?: number | null;
+    pipeline_step?: string | null;
+    metadata?: Record<string, unknown> | null;
+    context?: Record<string, unknown> | null;
+    created_at: string;
+}
+export interface ActivityResponse {
+    items: ActivityItem[];
+    total: number;
+    limit: number;
+}
+export interface ApiWebhook {
+    id: string;
+    workspace_id: string | null;
+    url: string;
+    description: string | null;
+    events: string[];
+    is_active: boolean;
+    created_at: string;
+    updated_at: string | null;
+    last_delivery_at: string | null;
+    last_delivery_status: number | null;
+    last_error: string | null;
+}
+export interface WebhookResponse {
+    webhook: ApiWebhook;
+    secret?: string;
+}
+export interface PlatformSchema {
+    id: string;
+    aliases: string[];
+    label: string;
+    status: 'supported' | 'planned';
+    summary: string;
+    content_limit: number | null;
+    media: Record<string, unknown>;
+    post_types: string[];
+    analytics_supported: boolean;
+    settings_schema: {
+        fields: Array<Record<string, unknown>>;
+        example: Record<string, unknown>;
+    };
+    helper_tools: Array<Record<string, unknown>>;
+    native_features: string[];
+}
+export interface ConnectOption {
+    platform: string;
+    aliases: string[];
+    label: string;
+    status: 'supported' | 'planned';
+    method: 'dashboard_oauth' | 'manual_credentials' | 'planned';
+    provider_platforms: string[];
+    dashboard_url: string;
+    connection_url: string | null;
+    oauth_url: string | null;
+    supports_direct_oauth_url: boolean;
+    requires_browser_session: boolean;
+    configured: boolean | null;
+    env_requirements: Array<Record<string, unknown>>;
+    missing_env: string[][];
+    scopes: string[];
+    credential_fields: Array<Record<string, unknown>>;
+    notes: string[];
+    connected_count?: number;
+    connected_accounts?: Account[];
+}
+export interface OAuthDeveloperClient {
+    id: string;
+    client_id: string;
+    client_name: string;
+    description?: string | null;
+    homepage?: string | null;
+    allowed_redirect_uris: string[];
+    default_scopes: string[];
+    is_active: boolean;
+    created_at?: string;
+    updated_at?: string;
+}
+export interface VideoJob {
+    id: string;
+    status: string;
+    prompt: string;
+    model: string;
+    duration_seconds: number;
+    aspect_ratio?: string;
+    resolution?: string;
+    generation_mode?: string | null;
+    credit_cost: number;
+    included_credit_cost?: number;
+    purchased_credit_cost?: number;
+    source_image_url?: string | null;
+    end_image_url?: string | null;
+    source_video_url?: string | null;
+    reference_images?: unknown;
+    generate_audio?: boolean | null;
+    video_url?: string | null;
+    error_message?: string | null;
+    created_at: string;
+    started_at?: string | null;
+    completed_at?: string | null;
+}
+export interface XPostingQuotaResponse {
+    workspace_id: string | null;
+    tier: string | null;
+    base_posts: number;
+    addon_posts: number;
+    total_posts: number;
+    used_posts: number;
+    remaining_posts: number;
+    current_period_start: string;
+    current_period_end: string;
+    urls_blocked: boolean;
+    addon?: Record<string, unknown>;
+    plans?: Array<Record<string, unknown>>;
+}
 export declare class PosterlyClient {
     private baseUrl;
     private apiKey;
@@ -241,6 +398,42 @@ export declare class PosterlyClient {
     listAccounts(params?: {
         workspace_id?: string;
     }): Promise<Account[]>;
+    disconnectAccount(accountId: string): Promise<Record<string, any>>;
+    getConnectLink(params?: {
+        platform?: string;
+        workspace_id?: string;
+        include_planned?: boolean;
+    }): Promise<{
+        connect?: ConnectOption;
+        connect_options?: ConnectOption[];
+    }>;
+    listOAuthClients(): Promise<{
+        clients: OAuthDeveloperClient[];
+    }>;
+    createOAuthClient(data: {
+        client_name: string;
+        description?: string;
+        homepage?: string;
+        allowed_redirect_uris: string[];
+        default_scopes: string[];
+        is_active?: boolean;
+    }): Promise<{
+        client: OAuthDeveloperClient;
+    }>;
+    updateOAuthClient(clientId: string, data: {
+        client_name?: string;
+        description?: string;
+        homepage?: string | null;
+        allowed_redirect_uris?: string[];
+        default_scopes?: string[];
+        is_active?: boolean;
+    }): Promise<{
+        client: OAuthDeveloperClient;
+    }>;
+    deleteOAuthClient(clientId: string): Promise<{
+        deleted: boolean;
+        client_id: string;
+    }>;
     listBrands(params?: {
         workspace_id?: string;
     }): Promise<Brand[]>;
@@ -269,6 +462,7 @@ export declare class PosterlyClient {
     getPost(id: number): Promise<{
         post: Post;
     }>;
+    getPostMissing(id: number): Promise<Record<string, any>>;
     updatePost(id: number, data: {
         caption?: string;
         scheduled_at?: string;
@@ -287,6 +481,15 @@ export declare class PosterlyClient {
         deleted: boolean;
         id: number;
     }>;
+    updatePostStatus(id: number, data: {
+        status: 'scheduled' | 'paused' | 'draft';
+        scheduled_at?: string;
+    }): Promise<Record<string, any>>;
+    updatePostReleaseId(id: number, data: {
+        release_id: string;
+        group_id?: string;
+    }): Promise<Record<string, any>>;
+    deletePostGroup(groupId: string): Promise<Record<string, any>>;
     generateImage(data: {
         prompt: string;
         aspect_ratio?: string;
@@ -312,6 +515,36 @@ export declare class PosterlyClient {
             billed_from: 'plan_quota' | 'credits';
         };
     }>;
+    getVideoOptions(): Promise<Record<string, any>>;
+    runVideoFunction(data: {
+        identifier: string;
+        functionName: string;
+        params?: Record<string, unknown>;
+    }): Promise<Record<string, any>>;
+    generateVideo(data: {
+        prompt: string;
+        negative_prompt?: string;
+        aspect_ratio?: '16:9' | '9:16';
+        duration_seconds?: 4 | 6 | 8;
+        resolution?: '720p' | '1080p';
+        model?: 'fast' | 'standard';
+        image_url?: string;
+        end_image_url?: string;
+        reference_images?: Array<{
+            url: string;
+            type: 'character' | 'object' | 'scene';
+        }>;
+        generate_audio?: boolean;
+        source_video_url?: string;
+    }): Promise<Record<string, any>>;
+    getVideoJob(params?: {
+        job_id?: string;
+        status?: string;
+        limit?: number;
+    }): Promise<{
+        job?: VideoJob;
+        jobs?: VideoJob[];
+    }>;
     findAvailableSlots(params?: {
         account_ids?: string[];
         timezone?: string;
@@ -330,6 +563,108 @@ export declare class PosterlyClient {
         limit?: number;
         offset?: number;
     }): Promise<PostAnalyticsResponse>;
+    listGoogleBusinessReviews(params?: {
+        workspace_id?: string;
+        account_id?: number;
+        location_id?: string;
+        rating?: number;
+        unanswered?: boolean;
+    }): Promise<GoogleBusinessReviewsResponse>;
+    getGoogleBusinessReviewLink(params: {
+        workspace_id?: string;
+        account_id?: number;
+        location_id?: string;
+    }): Promise<GoogleBusinessReviewLinkResponse>;
+    auditGoogleBusinessProfile(params: {
+        workspace_id?: string;
+        account_id?: number;
+        location_id?: string;
+    }): Promise<Record<string, any>>;
+    suggestGoogleBusinessReviewReply(data: {
+        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<Record<string, any>>;
+    replyGoogleBusinessReview(data: {
+        workspace_id?: string;
+        account_id?: number;
+        location_id?: string;
+        review_name: string;
+        comment: string;
+    }): Promise<Record<string, any>>;
+    deleteGoogleBusinessReviewReply(data: {
+        workspace_id?: string;
+        account_id?: number;
+        location_id?: string;
+        review_name: string;
+    }): Promise<Record<string, any>>;
+    listActivity(params?: {
+        workspace_id?: string;
+        post_id?: number;
+        since?: string;
+        type?: 'all' | 'activity' | 'publish';
+        limit?: number;
+    }): Promise<ActivityResponse>;
+    listWebhooks(params?: {
+        workspace_id?: string;
+    }): Promise<{
+        webhooks: ApiWebhook[];
+    }>;
+    createWebhook(data: {
+        url: string;
+        events?: string[];
+        workspace_id?: string;
+        description?: string;
+        is_active?: boolean;
+    }): Promise<WebhookResponse>;
+    updateWebhook(id: string, data: {
+        url?: string;
+        events?: string[];
+        workspace_id?: string | null;
+        description?: string | null;
+        is_active?: boolean;
+    }): Promise<WebhookResponse>;
+    deleteWebhook(id: string): Promise<{
+        deleted: boolean;
+        id: string;
+    }>;
+    testWebhook(id: string): Promise<{
+        delivery: Record<string, unknown>;
+    }>;
+    listPlatforms(params?: {
+        include_planned?: boolean;
+    }): Promise<{
+        platforms: PlatformSchema[];
+    }>;
+    getPlatformSchema(params: {
+        account_id?: string;
+        platform?: string;
+        include_planned?: boolean;
+    }): Promise<{
+        account?: Record<string, unknown>;
+        schema?: PlatformSchema;
+        platform?: PlatformSchema;
+        platforms?: PlatformSchema[];
+    }>;
+    triggerPlatformHelper(data: {
+        helper: string;
+        account_id?: string;
+        platform?: string;
+        params?: Record<string, unknown>;
+    }): Promise<{
+        helper: string;
+        account: Record<string, unknown> | null;
+        result: unknown;
+    }>;
+    getXPostingQuota(params?: {
+        workspace_id?: string;
+    }): Promise<XPostingQuotaResponse>;
     getSignedUploadUrl(filename: string, contentType: string, size: number): Promise<{
         upload_url: string;
         token: string;
@@ -345,4 +680,15 @@ export declare class PosterlyClient {
         url: string;
         path: string;
     }>;
+    uploadMediaFromUrl(input: {
+        url: string;
+        filename?: string;
+        contentType?: string;
+    }): Promise<{
+        url: string;
+        path: string;
+        source_url: string;
+        content_type: string;
+        size: number;
+    }>;
 }

package/dist/lib/api-client.js

@@ -41,6 +41,33 @@ export class PosterlyClient {
         const data = await this.request('GET', `/accounts${qs ? `?${qs}` : ''}`);
         return data.accounts;
     }
+    async disconnectAccount(accountId) {
+        return this.request('DELETE', `/accounts/${encodeURIComponent(accountId)}`);
+    }
+    async getConnectLink(params) {
+        const searchParams = new URLSearchParams();
+        if (params?.workspace_id)
+            searchParams.set('workspace_id', params.workspace_id);
+        if (params?.include_planned)
+            searchParams.set('include_planned', 'true');
+        const qs = searchParams.toString();
+        const path = params?.platform
+            ? `/connect/${encodeURIComponent(params.platform)}`
+            : '/connect';
+        return this.request('GET', `${path}${qs ? `?${qs}` : ''}`);
+    }
+    async listOAuthClients() {
+        return this.request('GET', '/oauth/clients');
+    }
+    async createOAuthClient(data) {
+        return this.request('POST', '/oauth/clients', data);
+    }
+    async updateOAuthClient(clientId, data) {
+        return this.request('PATCH', `/oauth/clients/${encodeURIComponent(clientId)}`, data);
+    }
+    async deleteOAuthClient(clientId) {
+        return this.request('DELETE', `/oauth/clients/${encodeURIComponent(clientId)}`);
+    }
     async listBrands(params) {
         const searchParams = new URLSearchParams();
         if (params?.workspace_id)
@@ -85,15 +112,48 @@ export class PosterlyClient {
     async getPost(id) {
         return this.request('GET', `/posts/${id}`);
     }
+    async getPostMissing(id) {
+        return this.request('GET', `/posts/${id}/missing`);
+    }
     async updatePost(id, data) {
         return this.request('PATCH', `/posts/${id}`, data);
     }
     async deletePost(id) {
         return this.request('DELETE', `/posts/${id}`);
     }
+    async updatePostStatus(id, data) {
+        return this.request('PUT', `/posts/${id}/status`, data);
+    }
+    async updatePostReleaseId(id, data) {
+        return this.request('PUT', `/posts/${id}/release-id`, data);
+    }
+    async deletePostGroup(groupId) {
+        return this.request('DELETE', `/posts/group/${encodeURIComponent(groupId)}?confirm=true`);
+    }
     async generateImage(data) {
         return this.request('POST', '/ai/generate-image', data);
     }
+    async getVideoOptions() {
+        return this.request('GET', '/ai/video-options');
+    }
+    async runVideoFunction(data) {
+        return this.request('POST', '/ai/video-function', data);
+    }
+    async generateVideo(data) {
+        return this.request('POST', '/ai/generate-video', data);
+    }
+    async getVideoJob(params) {
+        if (params?.job_id) {
+            return this.request('GET', `/ai/video-jobs/${encodeURIComponent(params.job_id)}`);
+        }
+        const searchParams = new URLSearchParams();
+        if (params?.status)
+            searchParams.set('status', params.status);
+        if (params?.limit)
+            searchParams.set('limit', String(params.limit));
+        const qs = searchParams.toString();
+        return this.request('GET', `/ai/video-jobs${qs ? `?${qs}` : ''}`);
+    }
     async findAvailableSlots(params) {
         const searchParams = new URLSearchParams();
         if (params?.account_ids?.length)
@@ -130,6 +190,112 @@ export class PosterlyClient {
             searchParams.set('offset', String(params.offset));
         return this.request('GET', `/analytics/posts?${searchParams.toString()}`);
     }
+    async listGoogleBusinessReviews(params) {
+        const searchParams = new URLSearchParams();
+        if (params?.workspace_id)
+            searchParams.set('workspace_id', params.workspace_id);
+        if (params?.account_id)
+            searchParams.set('account_id', String(params.account_id));
+        if (params?.location_id)
+            searchParams.set('location_id', params.location_id);
+        if (params?.rating)
+            searchParams.set('rating', String(params.rating));
+        if (params?.unanswered)
+            searchParams.set('unanswered', 'true');
+        const qs = searchParams.toString();
+        return this.request('GET', `/google-business/reviews${qs ? `?${qs}` : ''}`);
+    }
+    async getGoogleBusinessReviewLink(params) {
+        const searchParams = new URLSearchParams();
+        if (params.workspace_id)
+            searchParams.set('workspace_id', params.workspace_id);
+        if (params.account_id)
+            searchParams.set('account_id', String(params.account_id));
+        if (params.location_id)
+            searchParams.set('location_id', params.location_id);
+        return this.request('GET', `/google-business/review-link?${searchParams.toString()}`);
+    }
+    async auditGoogleBusinessProfile(params) {
+        const searchParams = new URLSearchParams();
+        if (params.workspace_id)
+            searchParams.set('workspace_id', params.workspace_id);
+        if (params.account_id)
+            searchParams.set('account_id', String(params.account_id));
+        if (params.location_id)
+            searchParams.set('location_id', params.location_id);
+        return this.request('GET', `/google-business/audit?${searchParams.toString()}`);
+    }
+    async suggestGoogleBusinessReviewReply(data) {
+        return this.request('POST', '/google-business/reviews/suggest-reply', data);
+    }
+    async replyGoogleBusinessReview(data) {
+        return this.request('POST', '/google-business/reviews/reply', data);
+    }
+    async deleteGoogleBusinessReviewReply(data) {
+        return this.request('DELETE', '/google-business/reviews/reply', data);
+    }
+    async listActivity(params) {
+        const searchParams = new URLSearchParams();
+        if (params?.workspace_id)
+            searchParams.set('workspace_id', params.workspace_id);
+        if (params?.post_id)
+            searchParams.set('post_id', String(params.post_id));
+        if (params?.since)
+            searchParams.set('since', params.since);
+        if (params?.type)
+            searchParams.set('type', params.type);
+        if (params?.limit)
+            searchParams.set('limit', String(params.limit));
+        const qs = searchParams.toString();
+        return this.request('GET', `/activity${qs ? `?${qs}` : ''}`);
+    }
+    async listWebhooks(params) {
+        const searchParams = new URLSearchParams();
+        if (params?.workspace_id)
+            searchParams.set('workspace_id', params.workspace_id);
+        const qs = searchParams.toString();
+        return this.request('GET', `/webhooks${qs ? `?${qs}` : ''}`);
+    }
+    async createWebhook(data) {
+        return this.request('POST', '/webhooks', data);
+    }
+    async updateWebhook(id, data) {
+        return this.request('PATCH', `/webhooks/${encodeURIComponent(id)}`, data);
+    }
+    async deleteWebhook(id) {
+        return this.request('DELETE', `/webhooks/${encodeURIComponent(id)}`);
+    }
+    async testWebhook(id) {
+        return this.request('POST', `/webhooks/${encodeURIComponent(id)}/test`, {});
+    }
+    async listPlatforms(params) {
+        const searchParams = new URLSearchParams();
+        if (params?.include_planned)
+            searchParams.set('include_planned', 'true');
+        const qs = searchParams.toString();
+        return this.request('GET', `/platforms${qs ? `?${qs}` : ''}`);
+    }
+    async getPlatformSchema(params) {
+        if (params.account_id) {
+            return this.request('GET', `/accounts/${encodeURIComponent(params.account_id)}/schema`);
+        }
+        const searchParams = new URLSearchParams();
+        if (params.platform)
+            searchParams.set('platform', params.platform);
+        if (params.include_planned)
+            searchParams.set('include_planned', 'true');
+        return this.request('GET', `/platforms?${searchParams.toString()}`);
+    }
+    async triggerPlatformHelper(data) {
+        return this.request('POST', '/platforms/trigger', data);
+    }
+    async getXPostingQuota(params) {
+        const searchParams = new URLSearchParams();
+        if (params?.workspace_id)
+            searchParams.set('workspace_id', params.workspace_id);
+        const qs = searchParams.toString();
+        return this.request('GET', `/x-posting/quota${qs ? `?${qs}` : ''}`);
+    }
     async getSignedUploadUrl(filename, contentType, size) {
         return this.request('POST', '/media/signed-upload', {
             filename,
@@ -175,6 +341,13 @@ export class PosterlyClient {
             content_type: contentType,
         });
     }
+    async uploadMediaFromUrl(input) {
+        return this.request('POST', '/media/upload-from-url', {
+            url: input.url,
+            filename: input.filename,
+            content_type: input.contentType,
+        });
+    }
 }
 function guessContentType(filename) {
     const ext = filename.split('.').pop()?.toLowerCase();

package/dist/tools/audit-google-business-profile.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const auditGoogleBusinessProfileTool: {
+    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/audit-google-business-profile.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export const auditGoogleBusinessProfileTool = {
+    name: 'audit_google_business_profile',
+    description: 'Run a live local-profile audit for a connected Google Business Profile location, including completeness, categories, media, attributes, reviews, and recommendations.',
+    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.auditGoogleBusinessProfile(input);
+        const audit = result.audit || {};
+        const recommendations = Array.isArray(audit.recommendations) ? audit.recommendations : [];
+        const lines = [
+            `Google Business audit: ${audit.businessName || 'Unknown business'}`,
+            `Score: ${audit.overallScore ?? 'n/a'} (${audit.overallGrade || 'n/a'})`,
+            `Fetched: ${result.fetchedAt || 'unknown'}`,
+        ];
+        if (recommendations.length > 0) {
+            lines.push('Top recommendations:');
+            for (const rec of recommendations.slice(0, 5)) {
+                lines.push(`- ${rec.priority || 'medium'}: ${rec.description || rec.title || 'Recommendation'}`);
+            }
+        }
+        return lines.join('\n');
+    },
+};

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

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