posterly-mcp-server 0.44.0 → 0.45.0

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

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+import { type ToolContext } from '../lib/tool-runtime.js';
+type JobsInput = {
+    type: 'image' | 'video';
+    job_id?: string;
+    status?: string;
+    limit?: number;
+};
+export declare const listJobsTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        type: z.ZodEnum<["image", "video"]>;
+        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, {
+        type: "image" | "video";
+        status?: "failed" | "pending" | "dismissed" | "completed" | "processing" | undefined;
+        limit?: number | undefined;
+        job_id?: string | undefined;
+    }, {
+        type: "image" | "video";
+        status?: "failed" | "pending" | "dismissed" | "completed" | "processing" | undefined;
+        limit?: number | undefined;
+        job_id?: string | undefined;
+    }>;
+    /** The old tools' exact input schemas, for alias calls (see alias-transport.ts). */
+    legacySchemas: {
+        get_image_job: z.ZodObject<{
+            job_id: z.ZodOptional<z.ZodString>;
+            status: z.ZodOptional<z.ZodEnum<["pending", "processing", "completed", "failed"]>>;
+            limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        }, "strip", z.ZodTypeAny, {
+            status?: "failed" | "pending" | "completed" | "processing" | undefined;
+            limit?: number | undefined;
+            job_id?: string | undefined;
+        }, {
+            status?: "failed" | "pending" | "completed" | "processing" | undefined;
+            limit?: number | undefined;
+            job_id?: string | undefined;
+        }>;
+        get_video_job: 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?: "failed" | "pending" | "dismissed" | "completed" | "processing" | undefined;
+            limit?: number | undefined;
+            job_id?: string | undefined;
+        }, {
+            status?: "failed" | "pending" | "dismissed" | "completed" | "processing" | undefined;
+            limit?: number | undefined;
+            job_id?: string | undefined;
+        }>;
+    };
+    execute(client: PosterlyClient, input: JobsInput, ctx: ToolContext): Promise<string>;
+};
+export {};

package/dist/tools/list-jobs.js

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+import { validateArgs } from '../lib/tool-runtime.js';
+export const listJobsTool = {
+    name: 'list_jobs',
+    description: 'AI generation jobs. type=image: one image job by job_id, or recent image jobs when job_id is omitted (filter by status, limit); poll it after generate_image for the finished urls. type=video: one Veo or Grok video job by job_id, or recent video jobs (status includes dismissed, limit); poll it after generate_video for the finished video_url.',
+    inputSchema: z.object({
+        type: z.enum(['image', 'video']).describe('image or video.'),
+        job_id: z.string().optional().describe('One job. Leave out to list recent jobs.'),
+        status: z
+            .enum(['pending', 'processing', 'completed', 'failed', 'dismissed'])
+            .optional()
+            .describe('Filter a job list. dismissed is video only.'),
+        limit: z.number().int().min(1).max(50).default(10).optional(),
+    }),
+    /** The old tools' exact input schemas, for alias calls (see alias-transport.ts). */
+    legacySchemas: {
+        get_image_job: z.object({
+            job_id: z.string().optional(),
+            status: z.enum(['pending', 'processing', 'completed', 'failed']).optional(),
+            limit: z.number().int().min(1).max(50).default(10).optional(),
+        }),
+        get_video_job: 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, ctx) {
+        const { mode, args } = validateArgs(ctx, 'list_jobs', input);
+        if (args.job_id) {
+            const extra = ['status', 'limit'].filter((key) => args[key] !== undefined);
+            if (extra.length) {
+                throw new Error(`${extra.join(' and ')} cannot be combined with job_id. Pass job_id alone for one job, or leave it out to list recent jobs.`);
+            }
+        }
+        const params = { job_id: args.job_id, status: args.status, limit: args.limit };
+        return mode === 'video' ? videoJobs(client, params) : imageJobs(client, params);
+    },
+};
+async function imageJobs(client, input) {
+    const result = await client.getImageJob(input);
+    if (result.job)
+        return formatImageJob(result.job, true);
+    const jobs = result.jobs || [];
+    return [
+        `Image jobs (${jobs.length})`,
+        jobs.map((job) => formatImageJob(job, false)).join('\n\n'),
+    ].filter(Boolean).join('\n');
+}
+async function videoJobs(client, input) {
+    const result = await client.getVideoJob(input);
+    if (result.job)
+        return formatVideoJob(result.job, true);
+    const jobs = result.jobs || [];
+    return [
+        `Video jobs (${jobs.length})`,
+        jobs.map((job) => formatVideoJob(job, false)).join('\n\n'),
+    ].filter(Boolean).join('\n');
+}
+function formatImageJob(job, includeRaw) {
+    const lines = [
+        `${job.id}: ${job.status}`,
+        `Prompt: ${job.prompt}`,
+        `Model: ${job.model}; resolution: ${job.resolution}; thinking: ${job.thinking_level || 'n/a'}; cost: ${job.credit_cost}`,
+        job.urls?.length ? `URLs: ${job.urls.join(', ')}` : 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');
+}
+function formatVideoJob(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/list-platforms.d.ts

@@ -1,16 +1,75 @@
 import { z } from 'zod';
 import type { PosterlyClient } from '../lib/api-client.js';
+import { type ToolContext } from '../lib/tool-runtime.js';
+type ListPlatformsInput = {
+    view?: 'platforms' | 'schema' | 'connect_link';
+    include_planned?: boolean;
+    account_id?: string;
+    platform?: string;
+    target?: string;
+    workspace_id?: string;
+    debug?: boolean;
+};
 export declare const listPlatformsTool: {
     name: string;
     description: string;
     inputSchema: z.ZodObject<{
+        view: z.ZodOptional<z.ZodEnum<["platforms", "schema", "connect_link"]>>;
+        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", "lemmy", "linkedin", "mastodon", "medium", "pinterest", "reddit", "skool", "slack", "telegram", "threads", "tiktok", "twitter", "whop", "wordpress", "x", "youtube"]>>;
+        target: z.ZodOptional<z.ZodEnum<["bluesky", "devto", "discord", "facebook", "facebook_instagram", "facebook_pages", "gmb", "google-business", "google_business", "google_business_profile", "hashnode", "instagram", "instagram-standalone", "instagram_direct", "lemmy", "linkedin", "linkedin-company", "linkedin-page", "linkedin_company", "linkedin_page", "linkedin_personal", "mastodon", "medium", "meta", "meta_business", "pinterest", "reddit", "skool", "slack", "telegram", "threads", "tiktok", "twitter", "whop", "wordpress", "x", "x_twitter", "youtube"]>>;
+        workspace_id: z.ZodOptional<z.ZodString>;
         include_planned: z.ZodOptional<z.ZodBoolean>;
+        debug: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
+        platform?: "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "threads" | "linkedin" | "youtube" | "pinterest" | "google_business" | "medium" | "x" | "telegram" | "bluesky" | "discord" | "wordpress" | "devto" | "hashnode" | "lemmy" | "slack" | "mastodon" | "reddit" | "skool" | "whop" | "gmb" | "google-business" | "google_business_profile" | undefined;
+        workspace_id?: string | undefined;
         include_planned?: boolean | undefined;
+        account_id?: string | undefined;
+        view?: "platforms" | "schema" | "connect_link" | undefined;
+        debug?: boolean | undefined;
+        target?: "meta" | "instagram_direct" | "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "threads" | "linkedin" | "youtube" | "pinterest" | "google_business" | "medium" | "x" | "telegram" | "bluesky" | "discord" | "wordpress" | "devto" | "hashnode" | "lemmy" | "slack" | "mastodon" | "reddit" | "skool" | "whop" | "gmb" | "google-business" | "google_business_profile" | "linkedin_page" | "facebook_instagram" | "facebook_pages" | "linkedin-company" | "linkedin-page" | "linkedin_company" | "linkedin_personal" | "meta_business" | "x_twitter" | undefined;
     }, {
+        platform?: "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "threads" | "linkedin" | "youtube" | "pinterest" | "google_business" | "medium" | "x" | "telegram" | "bluesky" | "discord" | "wordpress" | "devto" | "hashnode" | "lemmy" | "slack" | "mastodon" | "reddit" | "skool" | "whop" | "gmb" | "google-business" | "google_business_profile" | undefined;
+        workspace_id?: string | undefined;
         include_planned?: boolean | undefined;
+        account_id?: string | undefined;
+        view?: "platforms" | "schema" | "connect_link" | undefined;
+        debug?: boolean | undefined;
+        target?: "meta" | "instagram_direct" | "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "threads" | "linkedin" | "youtube" | "pinterest" | "google_business" | "medium" | "x" | "telegram" | "bluesky" | "discord" | "wordpress" | "devto" | "hashnode" | "lemmy" | "slack" | "mastodon" | "reddit" | "skool" | "whop" | "gmb" | "google-business" | "google_business_profile" | "linkedin_page" | "facebook_instagram" | "facebook_pages" | "linkedin-company" | "linkedin-page" | "linkedin_company" | "linkedin_personal" | "meta_business" | "x_twitter" | undefined;
     }>;
-    execute(client: PosterlyClient, input: {
-        include_planned?: boolean;
-    }): Promise<string>;
+    /** The old tools' exact input schemas, for alias calls (see alias-transport.ts). */
+    legacySchemas: {
+        get_platform_schema: 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", "lemmy", "linkedin", "mastodon", "medium", "pinterest", "reddit", "skool", "slack", "telegram", "threads", "tiktok", "twitter", "whop", "wordpress", "x", "youtube"]>>;
+            include_planned: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            platform?: "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "threads" | "linkedin" | "youtube" | "pinterest" | "google_business" | "medium" | "x" | "telegram" | "bluesky" | "discord" | "wordpress" | "devto" | "hashnode" | "lemmy" | "slack" | "mastodon" | "reddit" | "skool" | "whop" | "gmb" | "google-business" | "google_business_profile" | undefined;
+            include_planned?: boolean | undefined;
+            account_id?: string | undefined;
+        }, {
+            platform?: "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "threads" | "linkedin" | "youtube" | "pinterest" | "google_business" | "medium" | "x" | "telegram" | "bluesky" | "discord" | "wordpress" | "devto" | "hashnode" | "lemmy" | "slack" | "mastodon" | "reddit" | "skool" | "whop" | "gmb" | "google-business" | "google_business_profile" | undefined;
+            include_planned?: boolean | undefined;
+            account_id?: string | undefined;
+        }>;
+        get_connect_link: z.ZodObject<{
+            platform: z.ZodOptional<z.ZodEnum<["bluesky", "devto", "discord", "facebook", "facebook_instagram", "facebook_pages", "gmb", "google-business", "google_business", "google_business_profile", "hashnode", "instagram", "instagram-standalone", "instagram_direct", "lemmy", "linkedin", "linkedin-company", "linkedin-page", "linkedin_company", "linkedin_page", "linkedin_personal", "mastodon", "medium", "meta", "meta_business", "pinterest", "reddit", "skool", "slack", "telegram", "threads", "tiktok", "twitter", "whop", "wordpress", "x", "x_twitter", "youtube"]>>;
+            workspace_id: z.ZodOptional<z.ZodString>;
+            include_planned: z.ZodOptional<z.ZodBoolean>;
+            debug: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            platform?: "meta" | "instagram_direct" | "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "threads" | "linkedin" | "youtube" | "pinterest" | "google_business" | "medium" | "x" | "telegram" | "bluesky" | "discord" | "wordpress" | "devto" | "hashnode" | "lemmy" | "slack" | "mastodon" | "reddit" | "skool" | "whop" | "gmb" | "google-business" | "google_business_profile" | "linkedin_page" | "facebook_instagram" | "facebook_pages" | "linkedin-company" | "linkedin-page" | "linkedin_company" | "linkedin_personal" | "meta_business" | "x_twitter" | undefined;
+            workspace_id?: string | undefined;
+            include_planned?: boolean | undefined;
+            debug?: boolean | undefined;
+        }, {
+            platform?: "meta" | "instagram_direct" | "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "threads" | "linkedin" | "youtube" | "pinterest" | "google_business" | "medium" | "x" | "telegram" | "bluesky" | "discord" | "wordpress" | "devto" | "hashnode" | "lemmy" | "slack" | "mastodon" | "reddit" | "skool" | "whop" | "gmb" | "google-business" | "google_business_profile" | "linkedin_page" | "facebook_instagram" | "facebook_pages" | "linkedin-company" | "linkedin-page" | "linkedin_company" | "linkedin_personal" | "meta_business" | "x_twitter" | undefined;
+            workspace_id?: string | undefined;
+            include_planned?: boolean | undefined;
+            debug?: boolean | undefined;
+        }>;
+    };
+    execute(client: PosterlyClient, input: ListPlatformsInput, ctx: ToolContext): Promise<string>;
 };
+export {};

package/dist/tools/list-platforms.js

@@ -1,20 +1,129 @@
 import { z } from 'zod';
-import { PLANNED_PLATFORM_IDS } from '../generated/platform-manifest.js';
+import { ALL_PLATFORM_INPUTS, CONNECT_INPUTS, PLANNED_PLATFORM_IDS, SUPPORTED_PLATFORM_IDS } from '../generated/platform-manifest.js';
+import { validateArgs } from '../lib/tool-runtime.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.',
+    description: 'Platforms, settings schemas, and connection links. view=platforms (default): posterly platform integrations, posting capabilities, content/media limits, settings schemas, helper tools, and analytics support (include_planned shows future integration possibilities). view=schema: the settings schema for one connected account_id (preferred: returns connection-specific capabilities, needed before Instagram native tags/collaborators) or one platform; account_id wins if both are given. view=connect_link: dashboard handoff links and readiness for every target, or one target (instagram, meta, linkedin_page, twitter, telegram, reddit, wordpress, ...); use connection_url in a logged-in browser (direct OAuth URLs are intentionally not exposed); credential platforms show the credential_fields that connect_account needs.',
     inputSchema: z.object({
+        view: z
+            .enum(['platforms', 'schema', 'connect_link'])
+            .optional()
+            .describe('platforms (default), schema, or connect_link.'),
+        account_id: z
+            .string()
+            .optional()
+            .describe('view=schema: connected account ID from list_accounts. Preferred because it returns account context.'),
+        platform: z
+            .enum(ALL_PLATFORM_INPUTS)
+            .optional()
+            .describe(`view=schema: platform ID such as ${SUPPORTED_PLATFORM_IDS.join(', ')}. Set include_planned to inspect planned providers.`),
+        target: z
+            .enum(CONNECT_INPUTS)
+            .optional()
+            .describe('view=connect_link: 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('view=connect_link: filter connected account counts to a workspace.'),
         include_planned: z
             .boolean()
             .optional()
             .describe(`Include planned integrations such as ${PLANNED_PLATFORM_IDS.join(', ')}.`),
+        debug: z
+            .boolean()
+            .optional()
+            .describe('view=connect_link: when true, include the raw connect option JSON for debugging. Keep false for normal user-facing agent flows.'),
     }),
-    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')}`;
+    /** The old tools' exact input schemas, for alias calls (see alias-transport.ts). */
+    legacySchemas: {
+        get_platform_schema: z.object({
+            account_id: z.string().optional(),
+            platform: z.enum(ALL_PLATFORM_INPUTS).optional(),
+            include_planned: z.boolean().optional(),
+        }),
+        get_connect_link: z.object({
+            platform: z.enum(CONNECT_INPUTS).optional(),
+            workspace_id: z.string().optional(),
+            include_planned: z.boolean().optional(),
+            debug: z.boolean().optional(),
+        }),
+    },
+    async execute(client, input, ctx) {
+        const { mode, args } = validateArgs(ctx, 'list_platforms', input);
+        if (mode === 'schema')
+            return platformSchema(client, args);
+        if (mode === 'connect_link')
+            return connectLink(client, args);
+        return platforms(client, args);
     },
 };
+async function platforms(client, input) {
+    const result = await client.listPlatforms({ include_planned: input.include_planned });
+    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')}`;
+}
+async function platformSchema(client, input) {
+    const result = await client.getPlatformSchema({ account_id: input.account_id, platform: input.platform, include_planned: input.include_planned });
+    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`
+        : '';
+    const instagramTaggingLine = result.account?.instagram_tagging
+        ? `Instagram tagging capabilities: ${JSON.stringify(result.account.instagram_tagging)}`
+        : '';
+    return [
+        `${schema.label} (${schema.id}) schema`,
+        accountLine.trim(),
+        instagramTaggingLine,
+        `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');
+}
+async function connectLink(client, input) {
+    const { debug } = input;
+    const result = await client.getConnectLink({
+        platform: input.target,
+        workspace_id: input.workspace_id,
+        include_planned: input.include_planned,
+    });
+    if (result.connect) {
+        return formatConnectOption(result.connect, Boolean(debug));
+    }
+    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/list-posts.d.ts

@@ -12,7 +12,7 @@ export declare const listPostsTool: {
         approval_status: z.ZodOptional<z.ZodEnum<["none", "pending_client", "approved", "changes_requested", "rejected"]>>;
         brand_id: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        platform?: "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "threads" | "linkedin" | "youtube" | "pinterest" | "google_business" | "x" | "telegram" | "bluesky" | "discord" | "slack" | "mastodon" | "devto" | "hashnode" | "wordpress" | "lemmy" | "gmb" | "google-business" | "google_business_profile" | undefined;
+        platform?: "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "threads" | "linkedin" | "youtube" | "pinterest" | "google_business" | "x" | "telegram" | "bluesky" | "discord" | "wordpress" | "devto" | "hashnode" | "lemmy" | "slack" | "mastodon" | "gmb" | "google-business" | "google_business_profile" | undefined;
         status?: string | undefined;
         workspace_id?: string | undefined;
         account_id?: string | undefined;
@@ -20,7 +20,7 @@ export declare const listPostsTool: {
         approval_status?: "none" | "pending_client" | "approved" | "changes_requested" | "rejected" | undefined;
         brand_id?: string | undefined;
     }, {
-        platform?: "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "threads" | "linkedin" | "youtube" | "pinterest" | "google_business" | "x" | "telegram" | "bluesky" | "discord" | "slack" | "mastodon" | "devto" | "hashnode" | "wordpress" | "lemmy" | "gmb" | "google-business" | "google_business_profile" | undefined;
+        platform?: "instagram" | "instagram-standalone" | "facebook" | "tiktok" | "twitter" | "threads" | "linkedin" | "youtube" | "pinterest" | "google_business" | "x" | "telegram" | "bluesky" | "discord" | "wordpress" | "devto" | "hashnode" | "lemmy" | "slack" | "mastodon" | "gmb" | "google-business" | "google_business_profile" | undefined;
         status?: string | undefined;
         workspace_id?: string | undefined;
         account_id?: string | undefined;

package/dist/tools/manage-comment.d.ts

@@ -0,0 +1,102 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+import { type ToolContext } from '../lib/tool-runtime.js';
+type ManageCommentInput = {
+    action: 'reply' | 'update' | 'delete';
+    comment_id: string;
+    content?: string;
+    type?: 'public' | 'private';
+    is_hidden?: boolean;
+    is_read?: boolean;
+    workspace_id?: string;
+    confirm?: boolean;
+    preview_id?: string;
+};
+export declare const manageCommentTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        action: z.ZodEnum<["reply", "update", "delete"]>;
+        comment_id: z.ZodString;
+        content: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodEnum<["public", "private"]>>;
+        is_hidden: z.ZodOptional<z.ZodBoolean>;
+        is_read: z.ZodOptional<z.ZodBoolean>;
+        workspace_id: z.ZodOptional<z.ZodString>;
+        confirm: z.ZodOptional<z.ZodBoolean>;
+        preview_id: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        action: "update" | "delete" | "reply";
+        comment_id: string;
+        confirm?: boolean | undefined;
+        preview_id?: string | undefined;
+        workspace_id?: string | undefined;
+        type?: "public" | "private" | undefined;
+        content?: string | undefined;
+        is_hidden?: boolean | undefined;
+        is_read?: boolean | undefined;
+    }, {
+        action: "update" | "delete" | "reply";
+        comment_id: string;
+        confirm?: boolean | undefined;
+        preview_id?: string | undefined;
+        workspace_id?: string | undefined;
+        type?: "public" | "private" | undefined;
+        content?: string | undefined;
+        is_hidden?: boolean | undefined;
+        is_read?: boolean | undefined;
+    }>;
+    /** The old tools' exact input schemas, for alias calls (see alias-transport.ts). */
+    legacySchemas: {
+        reply_to_comment: z.ZodObject<{
+            comment_id: z.ZodString;
+            content: z.ZodString;
+            type: z.ZodOptional<z.ZodEnum<["public", "private"]>>;
+            workspace_id: z.ZodOptional<z.ZodString>;
+            confirm: z.ZodLiteral<true>;
+        }, "strip", z.ZodTypeAny, {
+            confirm: true;
+            content: string;
+            comment_id: string;
+            workspace_id?: string | undefined;
+            type?: "public" | "private" | undefined;
+        }, {
+            confirm: true;
+            content: string;
+            comment_id: string;
+            workspace_id?: string | undefined;
+            type?: "public" | "private" | undefined;
+        }>;
+        update_comment: z.ZodObject<{
+            comment_id: z.ZodString;
+            is_hidden: z.ZodOptional<z.ZodBoolean>;
+            is_read: z.ZodOptional<z.ZodBoolean>;
+            workspace_id: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            comment_id: string;
+            workspace_id?: string | undefined;
+            is_hidden?: boolean | undefined;
+            is_read?: boolean | undefined;
+        }, {
+            comment_id: string;
+            workspace_id?: string | undefined;
+            is_hidden?: boolean | undefined;
+            is_read?: boolean | undefined;
+        }>;
+        delete_comment: z.ZodObject<{
+            comment_id: z.ZodString;
+            workspace_id: z.ZodOptional<z.ZodString>;
+            confirm: z.ZodLiteral<true>;
+        }, "strip", z.ZodTypeAny, {
+            confirm: true;
+            comment_id: string;
+            workspace_id?: string | undefined;
+        }, {
+            confirm: true;
+            comment_id: string;
+            workspace_id?: string | undefined;
+        }>;
+    };
+    execute(client: PosterlyClient, input: ManageCommentInput, ctx: ToolContext): Promise<string>;
+};
+export {};

package/dist/tools/manage-comment.js

@@ -0,0 +1,125 @@
+import { z } from 'zod';
+import { code, mdKeyValue, mdQuote, mdSection } from '../lib/format.js';
+import { previewThenConfirm, readFailedNote, readForPreview, validateArgs } from '../lib/tool-runtime.js';
+export const manageCommentTool = {
+    name: 'manage_comment',
+    description: 'Act on an inbox comment (Pro plan or higher plus posts:write). action=reply (comment_id, content): reply to an Instagram, Facebook Page, Threads, or LinkedIn Page comment; type private is Instagram only, the others take public replies only. action=update (comment_id, is_hidden and/or is_read): hide or unhide it on the platform, or mark it read or unread; reversible, no confirm needed. action=delete (comment_id): delete an Instagram or Facebook Page comment, irreversible and admin only; Threads replies cannot be deleted, hide them instead. reply and delete use preview then confirm: call without confirm to get a preview and preview_id, show it, then call again with confirm=true and that preview_id.',
+    inputSchema: z.object({
+        action: z.enum(['reply', 'update', 'delete']).describe('reply, update, or delete.'),
+        comment_id: z.string().min(1).describe('Comment ID from list_comments.'),
+        content: z.string().min(1).optional().describe('reply: reply text to post.'),
+        type: z.enum(['public', 'private']).optional().describe('reply: public (default) or private. Private is Instagram only.'),
+        is_hidden: z.boolean().optional().describe('update: hide or unhide the comment on Instagram, Facebook, or Threads.'),
+        is_read: z.boolean().optional().describe('update: mark the comment read or unread in posterly.'),
+        workspace_id: z.string().optional().describe('Optional. Omit to search every workspace you belong to; pass a workspace ID from whoami to limit to one.'),
+        confirm: z.boolean().optional().describe('reply and delete: leave out to get a preview; true only with the preview_id after the user approved it.'),
+        preview_id: z.string().optional().describe('reply and delete: the preview_id from the preview call. Required with confirm: true.'),
+    }),
+    /** The old tools' exact input schemas, for alias calls (see alias-transport.ts). */
+    legacySchemas: {
+        reply_to_comment: z.object({
+            comment_id: z.string().min(1),
+            content: z.string().min(1),
+            type: z.enum(['public', 'private']).optional(),
+            workspace_id: z.string().optional(),
+            confirm: z.literal(true),
+        }),
+        update_comment: z.object({
+            comment_id: z.string().min(1),
+            is_hidden: z.boolean().optional(),
+            is_read: z.boolean().optional(),
+            workspace_id: z.string().optional(),
+        }),
+        delete_comment: z.object({
+            comment_id: z.string().min(1),
+            workspace_id: z.string().optional(),
+            confirm: z.literal(true),
+        }),
+    },
+    async execute(client, input, ctx) {
+        const { mode, args } = validateArgs(ctx, 'manage_comment', input);
+        if (mode === 'update')
+            return updateComment(client, args);
+        if (mode === 'delete') {
+            return previewThenConfirm({
+                tool: 'manage_comment',
+                action: 'delete',
+                args,
+                nonce: false,
+                legacyRefusal: 'Refusing to delete comment without confirm=true after explicit user confirmation.',
+                ctx,
+                describe: async () => [
+                    await describeComment(client, args),
+                    'Deletes this comment from the posterly inbox and, on Instagram or Facebook, from the network. This cannot be undone. Threads replies cannot be deleted; hide them with action=update instead.',
+                ].join('\n\n'),
+                run: () => deleteComment(client, args),
+            });
+        }
+        return previewThenConfirm({
+            tool: 'manage_comment',
+            action: 'reply',
+            args,
+            nonce: true,
+            legacyRefusal: 'Refusing to reply to a comment without confirm=true after explicit user confirmation.',
+            ctx,
+            describe: async () => [
+                await describeComment(client, args),
+                mdSection(`Reply to post (${args.type === 'private' ? 'private' : 'public'})`, mdQuote(String(args.content ?? ''))),
+                'This posts on the social network as your account.',
+            ].join('\n\n'),
+            run: () => replyToComment(client, args),
+        });
+    },
+};
+async function describeComment(client, input) {
+    const read = await readForPreview(() => client.getComment({ comment_id: input.comment_id, workspace_id: input.workspace_id }));
+    if (!read.ok) {
+        return [readFailedNote(read.error), mdKeyValue([['Comment ID', code(input.comment_id)], ['Workspace', input.workspace_id ? code(input.workspace_id) : undefined]])].join('\n\n');
+    }
+    const comment = read.data.comment;
+    return mdSection('Comment', mdKeyValue([
+        ['Comment ID', code(String(comment.id))],
+        ['Platform', typeof comment.platform === 'string' ? comment.platform : 'unknown'],
+        ['Author', typeof comment.author_username === 'string' ? `@${comment.author_username}` : 'unknown'],
+        ['Content', typeof comment.content === 'string' ? comment.content : '(empty)'],
+    ]));
+}
+async function replyToComment(client, input) {
+    const result = await client.replyToComment({
+        comment_id: input.comment_id,
+        content: input.content,
+        type: input.type,
+        workspace_id: input.workspace_id,
+    });
+    return `Comment reply sent (${result.reply_type}, reply_id ${result.reply_id}).`;
+}
+async function updateComment(client, input) {
+    const result = await client.updateComment({
+        comment_id: input.comment_id,
+        is_hidden: input.is_hidden,
+        is_read: input.is_read,
+        workspace_id: input.workspace_id,
+    });
+    const comment = result.comment;
+    const parts = [`Comment ${String(comment.id)} updated.`];
+    if (typeof comment.is_hidden === 'boolean')
+        parts.push(`Hidden: ${comment.is_hidden ? 'yes' : 'no'}.`);
+    if (typeof comment.is_read === 'boolean')
+        parts.push(`Read: ${comment.is_read ? 'yes' : 'no'}.`);
+    return parts.join(' ');
+}
+async function deleteComment(client, input) {
+    if (input.confirm !== true) {
+        throw new Error('Refusing to delete comment without confirm=true after explicit user confirmation.');
+    }
+    await client.deleteComment(input.comment_id, input.workspace_id);
+    // Output kept byte-identical to the old delete_comment tool (its alias
+    // must match); the old name in the next-step line still works until the
+    // alias sunset.
+    return [
+        `Comment ${input.comment_id} deleted successfully.`,
+        'It has been deleted from the posterly inbox. On Instagram or Facebook it is also removed on the network when the platform call succeeds.',
+        '',
+        'Next step for the AI agent: tell the user the comment is gone. Threads replies cannot be deleted; hide them with update_comment instead.',
+    ].join('\n');
+}