postproxy-mcp 1.0.2 → 1.2.0

package/src/tools/queue.ts

@@ -0,0 +1,230 @@
+/**
+ * Queue tools: queues.list, queues.get, queues.create, queues.update, queues.delete, queues.next_slot
+ */
+
+import type { PostProxyClient } from "../api/client.js";
+import { createError, ErrorCodes } from "../utils/errors.js";
+import { logError } from "../utils/logger.js";
+
+const DAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+
+function formatTimeslots(timeslots: Array<{ id: number; day: number; time: string }>): string[] {
+  return timeslots.map((ts) => `${DAY_NAMES[ts.day]} at ${ts.time} (id: ${ts.id})`);
+}
+
+export async function handleQueuesList(
+  client: PostProxyClient,
+  args: { profile_group_id?: string }
+) {
+  try {
+    const queues = await client.listQueues(args.profile_group_id);
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              queues: queues.map((q) => ({
+                id: q.id,
+                name: q.name,
+                description: q.description,
+                timezone: q.timezone,
+                enabled: q.enabled,
+                jitter: q.jitter,
+                profile_group_id: q.profile_group_id,
+                timeslots: formatTimeslots(q.timeslots),
+                posts_count: q.posts_count,
+              })),
+            },
+            null,
+            2
+          ),
+        },
+      ],
+    };
+  } catch (error) {
+    logError(error as Error, "queues.list");
+    throw createError(ErrorCodes.API_ERROR, `Failed to list queues: ${(error as Error).message}`);
+  }
+}
+
+export async function handleQueuesGet(
+  client: PostProxyClient,
+  args: { queue_id: string }
+) {
+  if (!args.queue_id) {
+    throw createError(ErrorCodes.VALIDATION_ERROR, "queue_id is required");
+  }
+
+  try {
+    const queue = await client.getQueue(args.queue_id);
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              ...queue,
+              timeslots_formatted: formatTimeslots(queue.timeslots),
+            },
+            null,
+            2
+          ),
+        },
+      ],
+    };
+  } catch (error) {
+    logError(error as Error, "queues.get");
+    throw createError(ErrorCodes.API_ERROR, `Failed to get queue: ${(error as Error).message}`);
+  }
+}
+
+export async function handleQueuesCreate(
+  client: PostProxyClient,
+  args: {
+    profile_group_id: string;
+    name: string;
+    description?: string;
+    timezone?: string;
+    jitter?: number;
+    timeslots?: Array<{ day: number; time: string }>;
+  }
+) {
+  if (!args.profile_group_id) {
+    throw createError(ErrorCodes.VALIDATION_ERROR, "profile_group_id is required");
+  }
+  if (!args.name) {
+    throw createError(ErrorCodes.VALIDATION_ERROR, "name is required");
+  }
+
+  try {
+    const queue = await client.createQueue({
+      profile_group_id: args.profile_group_id,
+      name: args.name,
+      description: args.description,
+      timezone: args.timezone,
+      jitter: args.jitter,
+      timeslots: args.timeslots,
+    });
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              ...queue,
+              timeslots_formatted: formatTimeslots(queue.timeslots),
+              message: "Queue created successfully",
+            },
+            null,
+            2
+          ),
+        },
+      ],
+    };
+  } catch (error) {
+    logError(error as Error, "queues.create");
+    throw createError(ErrorCodes.API_ERROR, `Failed to create queue: ${(error as Error).message}`);
+  }
+}
+
+export async function handleQueuesUpdate(
+  client: PostProxyClient,
+  args: {
+    queue_id: string;
+    name?: string;
+    description?: string;
+    timezone?: string;
+    enabled?: boolean;
+    jitter?: number;
+    timeslots?: Array<{ day: number; time: string } | { id: number; _destroy: true }>;
+  }
+) {
+  if (!args.queue_id) {
+    throw createError(ErrorCodes.VALIDATION_ERROR, "queue_id is required");
+  }
+
+  try {
+    const queue = await client.updateQueue(args.queue_id, {
+      name: args.name,
+      description: args.description,
+      timezone: args.timezone,
+      enabled: args.enabled,
+      jitter: args.jitter,
+      timeslots: args.timeslots,
+    });
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              ...queue,
+              timeslots_formatted: formatTimeslots(queue.timeslots),
+              message: "Queue updated successfully",
+            },
+            null,
+            2
+          ),
+        },
+      ],
+    };
+  } catch (error) {
+    logError(error as Error, "queues.update");
+    throw createError(ErrorCodes.API_ERROR, `Failed to update queue: ${(error as Error).message}`);
+  }
+}
+
+export async function handleQueuesDelete(
+  client: PostProxyClient,
+  args: { queue_id: string }
+) {
+  if (!args.queue_id) {
+    throw createError(ErrorCodes.VALIDATION_ERROR, "queue_id is required");
+  }
+
+  try {
+    await client.deleteQueue(args.queue_id);
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ queue_id: args.queue_id, deleted: true }, null, 2),
+        },
+      ],
+    };
+  } catch (error) {
+    logError(error as Error, "queues.delete");
+    throw createError(ErrorCodes.API_ERROR, `Failed to delete queue: ${(error as Error).message}`);
+  }
+}
+
+export async function handleQueuesNextSlot(
+  client: PostProxyClient,
+  args: { queue_id: string }
+) {
+  if (!args.queue_id) {
+    throw createError(ErrorCodes.VALIDATION_ERROR, "queue_id is required");
+  }
+
+  try {
+    const result = await client.getQueueNextSlot(args.queue_id);
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  } catch (error) {
+    logError(error as Error, "queues.next_slot");
+    throw createError(ErrorCodes.API_ERROR, `Failed to get next slot: ${(error as Error).message}`);
+  }
+}

package/src/types/index.ts

@@ -21,6 +21,20 @@ export interface Profile {
   avatar_url?: string;
 }
 
+export interface ThreadChild {
+  body: string;
+  media?: string[];
+}
+
+export interface MediaAttachment {
+  id: string;
+  status: "pending" | "processed" | "failed";
+  error_message: string | null;
+  content_type: string;
+  source_url: string | null;
+  url: string | null;
+}
+
 export interface CreatePostParams {
   content: string;
   profile_group_id?: number; // Not used by API, kept for compatibility
@@ -30,17 +44,22 @@ export interface CreatePostParams {
   idempotency_key?: string;
   draft?: boolean; // If true, creates a draft post that won't publish automatically
   platforms?: PlatformParams; // Platform-specific parameters
+  thread?: ThreadChild[]; // Thread posts (supported on X and Threads)
+  queue_id?: string; // Queue ID to add post to
+  queue_priority?: "high" | "medium" | "low"; // Queue priority (default: medium)
 }
 
 export interface CreatePostResponse {
   id: string;
   body?: string; // API returns "body" field
   content?: string; // Some responses use "content"
-  status: "draft" | "pending" | "processing" | "processed" | "scheduled";
+  status: "draft" | "pending" | "processing" | "processed" | "scheduled" | "media_processing_failed";
   draft: boolean;
   scheduled_at: string | null;
   created_at: string;
+  media?: MediaAttachment[];
   platforms: PlatformOutcome[];
+  thread?: Array<{ id: string; body: string; media?: MediaAttachment[] }>;
 }
 
 export interface PlatformOutcome {
@@ -62,24 +81,28 @@ export interface PostDetails {
   id: string;
   body?: string; // API returns "body" field
   content?: string; // Some responses use "content"
-  status: "draft" | "pending" | "processing" | "processed" | "scheduled";
+  status: "draft" | "pending" | "processing" | "processed" | "scheduled" | "media_processing_failed";
   draft: boolean;
   scheduled_at: string | null;
   created_at: string;
   updated_at?: string;
+  media?: MediaAttachment[];
   platforms: PlatformOutcome[];
+  thread?: Array<{ id: string; body: string; media?: MediaAttachment[] }>;
 }
 
 export interface Post {
   id: string;
   body?: string; // API returns "body" field
   content?: string; // Some responses use "content"
-  status: "draft" | "pending" | "processing" | "processed" | "scheduled";
+  status: "draft" | "pending" | "processing" | "processed" | "scheduled" | "media_processing_failed";
   draft: boolean;
   scheduled_at: string | null;
   created_at: string;
   updated_at?: string;
+  media?: MediaAttachment[];
   platforms: PlatformOutcome[];
+  thread?: Array<{ id: string; body: string; media?: MediaAttachment[] }>;
 }
 
 /**
@@ -102,21 +125,23 @@ export interface YouTubeParams {
   title?: string; // Video title
   privacy_status?: "public" | "unlisted" | "private"; // Video visibility
   cover_url?: string; // Custom thumbnail URL
+  made_for_kids?: boolean; // Whether the video is made for kids
 }
 
 /**
  * Platform-specific parameters for TikTok
  */
 export interface TikTokParams {
+  format?: "video" | "image"; // Content format (video is default)
   privacy_status?: "PUBLIC_TO_EVERYONE" | "MUTUAL_FOLLOW_FRIENDS" | "FOLLOWER_OF_CREATOR" | "SELF_ONLY";
-  photo_cover_index?: number; // Index (0-based) of photo to use as cover
-  auto_add_music?: boolean; // Enable automatic music
-  made_with_ai?: boolean; // Mark content as AI-generated
-  disable_comment?: boolean; // Disable comments on the post
-  disable_duet?: boolean; // Disable duets
-  disable_stitch?: boolean; // Disable stitches
-  brand_content_toggle?: boolean; // Mark video as paid partnership promoting a third-party business
-  brand_organic_toggle?: boolean; // Mark video as paid partnership promoting your own brand
+  photo_cover_index?: number; // Index (0-based) of photo to use as cover (image format)
+  auto_add_music?: boolean; // Enable automatic music (image format)
+  made_with_ai?: boolean; // Mark content as AI-generated (video format)
+  disable_comment?: boolean; // Disable comments
+  disable_duet?: boolean; // Disable duets (video format)
+  disable_stitch?: boolean; // Disable stitches (video format)
+  brand_content_toggle?: boolean; // Mark as paid partnership promoting a third-party business
+  brand_organic_toggle?: boolean; // Mark as paid partnership promoting your own brand
 }
 
 /**
@@ -198,3 +223,51 @@ export interface PostStats {
 export interface StatsResponse {
   data: Record<string, PostStats>;
 }
+
+/**
+ * Queue timeslot definition
+ */
+export interface QueueTimeslot {
+  id: number;
+  day: number; // 0=Sunday through 6=Saturday
+  time: string; // HH:MM format
+}
+
+/**
+ * Post queue
+ */
+export interface PostQueue {
+  id: string;
+  name: string;
+  description: string | null;
+  timezone: string;
+  enabled: boolean;
+  jitter: number;
+  profile_group_id: string;
+  timeslots: QueueTimeslot[];
+  posts_count: number;
+}
+
+/**
+ * Parameters for creating a queue
+ */
+export interface CreateQueueParams {
+  profile_group_id: string;
+  name: string;
+  description?: string;
+  timezone?: string;
+  jitter?: number;
+  timeslots?: Array<{ day: number; time: string }>;
+}
+
+/**
+ * Parameters for updating a queue
+ */
+export interface UpdateQueueParams {
+  name?: string;
+  description?: string;
+  timezone?: string;
+  enabled?: boolean;
+  jitter?: number;
+  timeslots?: Array<{ day: number; time: string } | { id: number; _destroy: true }>;
+}

package/src/utils/validation.ts

@@ -89,10 +89,14 @@ export const YouTubeParamsSchema = z.object({
     errorMap: () => ({ message: "YouTube privacy_status must be 'public', 'unlisted', or 'private'" }),
   }).optional(),
   cover_url: URLSchema.optional(),
+  made_for_kids: z.boolean().optional(),
 }).strict();
 
 // TikTok parameters validation
 export const TikTokParamsSchema = z.object({
+  format: z.enum(["video", "image"], {
+    errorMap: () => ({ message: "TikTok format must be 'video' or 'image'" }),
+  }).optional(),
   privacy_status: z.enum([
     "PUBLIC_TO_EVERYONE",
     "MUTUAL_FOLLOW_FRIENDS",
@@ -142,6 +146,14 @@ export const PlatformParamsSchema = z.object({
   threads: ThreadsParamsSchema.optional(),
 }).strict().optional();
 
+/**
+ * Schema for thread child posts
+ */
+export const ThreadChildSchema = z.object({
+  body: z.string().min(1, "Thread child body cannot be empty"),
+  media: z.array(MediaItemSchema).optional(),
+});
+
 /**
  * Schema for post.publish parameters
  */
@@ -154,6 +166,7 @@ export const PostPublishSchema = z.object({
   require_confirmation: z.boolean().optional(),
   draft: z.boolean().optional(),
   platforms: PlatformParamsSchema,
+  thread: z.array(ThreadChildSchema).optional(),
 });
 
 /**