@jclvsh/dropspace 2.0.0

package/dist/tools/personas.js

@@ -0,0 +1,152 @@
+import { z } from "zod";
+export function registerPersonaTools(server, client) {
+    server.tool("list_personas", "list your personas with pagination", {
+        page: z.number().int().positive().optional().describe("page number (default: 1)"),
+        page_size: z.number().int().min(1).max(100).optional().describe("items per page (default: 50, max: 100)"),
+    }, async ({ page, page_size }) => {
+        try {
+            const params = {};
+            if (page !== undefined)
+                params.page = String(page);
+            if (page_size !== undefined)
+                params.page_size = String(page_size);
+            const result = await client.get("/personas", params);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("create_persona", "create a new persona for AI content generation tone/style", {
+        name: z.string().min(1).max(100).describe("persona name (1-100 characters)"),
+    }, async ({ name }) => {
+        try {
+            const result = await client.post("/personas", {
+                name,
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("get_persona", "get a persona by ID with analysis details and writing samples", {
+        id: z.string().uuid().describe("persona ID"),
+    }, async ({ id }) => {
+        try {
+            const result = await client.get(`/personas/${id}`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("update_persona", "update a persona's name or writing samples", {
+        id: z.string().uuid().describe("persona ID"),
+        name: z.string().min(1).max(100).optional().describe("new persona name"),
+        custom_samples: z.array(z.unknown()).max(50).optional().describe("custom writing samples (max 50)"),
+        twitter_samples: z.array(z.unknown()).max(50).optional().describe("twitter writing samples (max 50)"),
+        reddit_samples: z.array(z.unknown()).max(50).optional().describe("reddit writing samples (max 50)"),
+        facebook_samples: z.array(z.unknown()).max(50).optional().describe("facebook writing samples (max 50)"),
+        instagram_samples: z.array(z.unknown()).max(50).optional().describe("instagram writing samples (max 50)"),
+        tiktok_samples: z.array(z.unknown()).max(50).optional().describe("tiktok writing samples (max 50)"),
+        linkedin_samples: z.array(z.unknown()).max(50).optional().describe("linkedin writing samples (max 50)"),
+    }, async ({ id, ...body }) => {
+        try {
+            const result = await client.patch(`/personas/${id}`, body);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("delete_persona", "delete a persona", {
+        id: z.string().uuid().describe("persona ID"),
+    }, async ({ id }) => {
+        try {
+            await client.delete(`/personas/${id}`);
+            return {
+                content: [{ type: "text", text: "persona deleted successfully" }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("analyze_persona", "trigger AI analysis of a persona's writing style (queued async)", {
+        id: z.string().uuid().describe("persona ID"),
+        platforms: z.array(z.string()).optional().describe("specific platforms to analyze samples from"),
+        include_custom_samples: z.boolean().optional().describe("include custom writing samples in analysis"),
+    }, async ({ id, platforms, include_custom_samples }) => {
+        try {
+            const body = {};
+            if (platforms)
+                body.platforms = platforms;
+            if (include_custom_samples !== undefined)
+                body.include_custom_samples = include_custom_samples;
+            const result = await client.post(`/personas/${id}/analyze`, body);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/usage.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { DropspaceClient } from "../client.js";
+export declare function registerUsageTools(server: McpServer, client: DropspaceClient): void;

package/dist/tools/usage.js

@@ -0,0 +1,21 @@
+export function registerUsageTools(server, client) {
+    server.tool("get_usage", "get your current plan, usage limits, and billing period (requires read scope)", {}, async () => {
+        try {
+            const result = await client.get("/usage");
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/webhooks.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { DropspaceClient } from "../client.js";
+export declare function registerWebhookTools(server: McpServer, client: DropspaceClient): void;

package/dist/tools/webhooks.js

@@ -0,0 +1,183 @@
+import { z } from "zod";
+const WEBHOOK_EVENTS = [
+    "launch.completed",
+    "launch.failed",
+    "launch.partial",
+    "media.ready",
+    "persona.analyzed",
+    "post.deleted",
+];
+export function registerWebhookTools(server, client) {
+    server.tool("list_webhooks", "list your webhooks (requires admin scope)", {}, async () => {
+        try {
+            const result = await client.get("/webhooks");
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("create_webhook", "create a webhook endpoint — the secret is returned once, store it securely (requires admin scope)", {
+        url: z
+            .string()
+            .url()
+            .refine((u) => u.startsWith("https://"), {
+            message: "webhook url must use https",
+        })
+            .describe("HTTPS webhook URL"),
+        events: z
+            .array(z.enum(WEBHOOK_EVENTS))
+            .min(1)
+            .describe("events to subscribe to: launch.completed, launch.failed, launch.partial, media.ready, persona.analyzed, post.deleted"),
+    }, async (args) => {
+        try {
+            const result = await client.post("/webhooks", args);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("get_webhook", "get a webhook by ID (requires admin scope)", {
+        id: z.string().uuid().describe("webhook ID"),
+    }, async ({ id }) => {
+        try {
+            const result = await client.get(`/webhooks/${id}`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("update_webhook", "update a webhook's URL, events, or active status (requires admin scope)", {
+        id: z.string().uuid().describe("webhook ID"),
+        url: z
+            .string()
+            .url()
+            .refine((u) => u.startsWith("https://"), {
+            message: "webhook url must use https",
+        })
+            .optional()
+            .describe("new HTTPS webhook URL"),
+        events: z.array(z.enum(WEBHOOK_EVENTS)).min(1).optional().describe("new events to subscribe to"),
+        active: z.boolean().optional().describe("enable or disable the webhook"),
+    }, async ({ id, ...body }) => {
+        try {
+            const result = await client.patch(`/webhooks/${id}`, body);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("delete_webhook", "delete a webhook (requires admin scope)", {
+        id: z.string().uuid().describe("webhook ID"),
+    }, async ({ id }) => {
+        try {
+            await client.delete(`/webhooks/${id}`);
+            return {
+                content: [{ type: "text", text: "webhook deleted successfully" }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("rotate_webhook_secret", "rotate a webhook's signing secret — the new secret is returned once, store it securely (requires admin scope)", {
+        id: z.string().uuid().describe("webhook ID"),
+    }, async ({ id }) => {
+        try {
+            const result = await client.post(`/webhooks/${id}/rotate-secret`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool("list_webhook_deliveries", "list delivery attempts for a webhook with pagination (requires admin scope)", {
+        id: z.string().uuid().describe("webhook ID"),
+        page: z.number().int().positive().optional().describe("page number (default: 1)"),
+        page_size: z.number().int().min(1).max(100).optional().describe("items per page (default: 50, max: 100)"),
+    }, async ({ id, page, page_size }) => {
+        try {
+            const params = {};
+            if (page !== undefined)
+                params.page = String(page);
+            if (page_size !== undefined)
+                params.page_size = String(page_size);
+            const result = await client.get(`/webhooks/${id}/deliveries`, params);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `error: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,257 @@
+/** Paginated API response wrapper */
+export interface PaginatedResponse<T> {
+    data: T[];
+    pagination: {
+        page: number;
+        page_size: number;
+        total: number;
+        total_pages: number;
+    };
+}
+/** Single-item API response wrapper */
+export interface DataResponse<T> {
+    data: T;
+}
+/** API error response */
+export interface ApiErrorResponse {
+    error: {
+        code: string;
+        message: string;
+        field?: string;
+    };
+}
+/** Launch resource */
+export interface Launch {
+    id: string;
+    name: string;
+    status: string;
+    platforms: string[];
+    scheduled_date: string | null;
+    product_url: string | null;
+    product_description: string | null;
+    persona_id: string | null;
+    media_mode: string | null;
+    dropspace_platforms: string[] | null;
+    user_platform_accounts: Record<string, string> | null;
+    platform_contents: Record<string, unknown> | null;
+    media_assets: unknown[] | null;
+    posting_status?: Record<string, PostingStatus>;
+    error_message: string | null;
+    started_at: string | null;
+    completed_at: string | null;
+    created_at: string;
+    updated_at: string;
+}
+/** Per-platform posting status */
+export interface PostingStatus {
+    status: string;
+    account_type?: string;
+    post_url?: string;
+    error_message?: string;
+    posted_at?: string;
+}
+/** Launch status detail */
+export interface LaunchStatusDetail {
+    launch_id: string;
+    launch_status: string;
+    posting_logs: PostingLog[];
+}
+/** Posting log entry */
+export interface PostingLog {
+    id: string;
+    platform: string;
+    status: string;
+    post_url: string | null;
+    post_id: string | null;
+    error_message: string | null;
+    error_code: string | null;
+    attempt_count: number;
+    posted_at: string | null;
+    created_at: string;
+}
+/** Launch analytics */
+export interface LaunchAnalytics {
+    launch_id: string;
+    launch_name: string;
+    launch_status: string;
+    summary: {
+        total: number;
+        successful: number;
+        failed: number;
+        pending: number;
+    };
+    fetched_at: string | null;
+    next_refresh_at: string | null;
+    platforms: Array<{
+        platform: string;
+        status: string;
+        post_url: string | null;
+        post_id: string | null;
+        posted_at: string | null;
+        cache_status?: string;
+        is_deleted?: boolean;
+        deleted_detected_at?: string | null;
+        deletion_reason?: string | null;
+        metrics: Record<string, unknown> | null;
+    }>;
+}
+/** Batch launch analytics item (no fetched_at/next_refresh_at — those are single-launch only) */
+export interface BatchLaunchAnalyticsItem {
+    launch_id: string;
+    launch_name: string;
+    launch_status: string;
+    summary: {
+        total: number;
+        successful: number;
+        failed: number;
+        pending: number;
+    };
+    platforms: Array<{
+        platform: string;
+        status: string;
+        post_url: string | null;
+        post_id: string | null;
+        posted_at: string | null;
+        cache_status?: string;
+        is_deleted?: boolean;
+        deleted_detected_at?: string | null;
+        deletion_reason?: string | null;
+        metrics: Record<string, unknown> | null;
+    }>;
+}
+/** Batch launch analytics response */
+export interface BatchLaunchAnalyticsResponse {
+    data: BatchLaunchAnalyticsItem[];
+    errors: Array<{
+        id: string;
+        error: {
+            code: string;
+            message: string;
+        };
+    }>;
+}
+/** Persona resource */
+export interface Persona {
+    id: string;
+    name: string;
+    persona_analysis: unknown | null;
+    persona_analysis_structured?: unknown | null;
+    build_status: string;
+    build_progress: number;
+    build_started_at: string | null;
+    build_error: string | null;
+    last_analyzed_at: string | null;
+    custom_samples?: unknown[];
+    twitter_samples?: unknown[];
+    reddit_samples?: unknown[];
+    facebook_samples?: unknown[];
+    instagram_samples?: unknown[];
+    tiktok_samples?: unknown[];
+    linkedin_samples?: unknown[];
+    created_at: string;
+    updated_at: string;
+}
+/** Connection (OAuth token) */
+export interface Connection {
+    id: string;
+    platform: string;
+    entity_id: string | null;
+    account_info: unknown | null;
+    account_type: string | null;
+    is_active: boolean;
+    expires_at: string | null;
+    created_at: string;
+    updated_at: string;
+}
+/** API key resource */
+export interface ApiKey {
+    id: string;
+    name: string;
+    key_prefix: string;
+    scopes: string[];
+    last_used_at: string | null;
+    revoked_at: string | null;
+    created_at: string;
+}
+/** Response when creating an API key (includes raw key, shown once) */
+export interface CreateApiKeyResponse {
+    key: string;
+    api_key: ApiKey;
+}
+/** Webhook resource */
+export interface Webhook {
+    id: string;
+    url: string;
+    events: string[];
+    secret?: string;
+    active: boolean;
+    created_at: string;
+    updated_at: string;
+}
+/** Response when rotating a webhook secret */
+export interface RotateSecretResponse {
+    id: string;
+    secret: string;
+}
+/** Webhook delivery log entry */
+export interface WebhookDelivery {
+    id: string;
+    webhook_id: string;
+    event_type: string;
+    status: string;
+    attempts: number;
+    response_status: number | null;
+    response_body: string | null;
+    delivered_at: string | null;
+    created_at: string;
+}
+/** Dropspace platform status entry */
+export interface DropspacePlatformStatus {
+    platform: string;
+    connected: boolean;
+    account_name?: string;
+}
+/** Dropspace account status */
+export interface DropspaceStatus {
+    platforms: DropspacePlatformStatus[];
+    connected_platforms: string[];
+    timestamp: string;
+}
+/** Usage limit entry (with used/remaining) */
+export interface UsageLimitEntry {
+    limit: number | "unlimited";
+    used: number;
+    remaining: number | "unlimited";
+}
+/** Usage limit entry (limit only, no tracked usage) */
+export interface UsageLimitOnly {
+    limit: number | "unlimited";
+}
+/** Usage and plan data */
+export interface UsageData {
+    plan: string;
+    billing_period: {
+        start: string;
+        end: string;
+    };
+    limits: {
+        launches_per_month: UsageLimitEntry;
+        ai_images_per_month: UsageLimitEntry;
+        ai_videos_per_month: UsageLimitEntry;
+        personas: UsageLimitEntry;
+        analyses_per_persona: UsageLimitOnly;
+        regenerations_per_launch: UsageLimitOnly;
+    };
+    features: {
+        can_connect_own_accounts: boolean;
+        can_post_to_official_accounts: boolean;
+        allowed_platforms: string[] | null;
+    };
+}
+/** Retry content generation response */
+export interface RetryContentResponse {
+    retried: string[];
+    succeeded: string[];
+    still_failing: string[];
+    rate_limited: string[];
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,33 @@
+{
+	"name": "@jclvsh/dropspace",
+	"version": "2.0.0",
+	"description": "MCP server and CLI for the Dropspace API",
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"bin": {
+		"dropspace-mcp": "dist/index.js",
+		"dropspace": "dist/cli.js"
+	},
+	"files": [
+		"dist",
+		"README.md"
+	],
+	"scripts": {
+		"build": "tsc",
+		"start": "node dist/index.js"
+	},
+	"dependencies": {
+		"@modelcontextprotocol/sdk": "^1.11.0",
+		"commander": "^14.0.3",
+		"zod": "^3.24.0"
+	},
+	"devDependencies": {
+		"@types/node": "^22.0.0",
+		"typescript": "^5.7.0"
+	},
+	"engines": {
+		"node": ">=18"
+	},
+	"license": "MIT"
+}