@jclvsh/dropspace 2.0.0

package/dist/commands/launches.js

@@ -0,0 +1,263 @@
+import { formatOutput, handleError, getFormat, parseList } from "../cli-utils.js";
+export function registerLaunchCommands(program, client) {
+    const launches = program.command("launches").alias("l").description("manage launches");
+    launches
+        .command("list")
+        .description("list launches with pagination")
+        .option("-p, --page <n>", "page number", "1")
+        .option("-s, --page-size <n>", "items per page (max 100)", "50")
+        .action(async (opts) => {
+        try {
+            const params = {};
+            if (opts.page)
+                params.page = opts.page;
+            if (opts.pageSize)
+                params.page_size = opts.pageSize;
+            const result = await client.get("/launches", params);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    launches
+        .command("create")
+        .description("create a new launch")
+        .requiredOption("-t, --title <title>", "launch title")
+        .option("-d, --description <text>", "product description")
+        .option("--platforms <list>", "comma-separated platforms", parseList)
+        .option("--url <url>", "product URL")
+        .option("--schedule <datetime>", "ISO 8601 schedule datetime")
+        .option("--persona <id>", "persona ID for tone/style")
+        .option("--dropspace-platforms <list>", "platforms for official dropspace accounts", parseList)
+        .option("--media-mode <mode>", "media mode: images or video")
+        .option("--platform-contents <json>", "per-platform content as JSON string")
+        .option("--custom-content <text>", "single content string for all platforms")
+        .option("--reddit-title <title>", "reddit title (with custom-content)")
+        .option("--user-accounts <json>", "platform-to-token_id map as JSON string")
+        .option("--publish", "immediately publish after creation")
+        .option("--wait", "wait for publishing to complete (requires --publish)")
+        .action(async (opts) => {
+        try {
+            const body = { title: opts.title };
+            if (opts.description)
+                body.product_description = opts.description;
+            if (opts.platforms)
+                body.platforms = opts.platforms;
+            if (opts.url)
+                body.product_url = opts.url;
+            if (opts.schedule)
+                body.scheduled_date = opts.schedule;
+            if (opts.persona)
+                body.persona_id = opts.persona;
+            if (opts.dropspacePlatforms)
+                body.dropspace_platforms = opts.dropspacePlatforms;
+            if (opts.mediaMode)
+                body.media_mode = opts.mediaMode;
+            if (opts.platformContents)
+                body.platform_contents = JSON.parse(opts.platformContents);
+            if (opts.customContent)
+                body.custom_content = opts.customContent;
+            if (opts.redditTitle)
+                body.custom_content_reddit_title = opts.redditTitle;
+            if (opts.userAccounts)
+                body.user_platform_accounts = JSON.parse(opts.userAccounts);
+            if (opts.publish)
+                body.publish = true;
+            if (opts.wait)
+                body.wait = true;
+            const result = await client.post("/launches", body);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    launches
+        .command("get <id>")
+        .description("get a launch by ID")
+        .action(async (id) => {
+        try {
+            const result = await client.get(`/launches/${id}`);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    launches
+        .command("update <id>")
+        .description("update a launch")
+        .option("-n, --name <name>", "launch name")
+        .option("-d, --description <text>", "product description")
+        .option("--platforms <list>", "comma-separated platforms", parseList)
+        .option("--url <url>", "product URL")
+        .option("--schedule <datetime>", "ISO 8601 schedule datetime (empty to clear)")
+        .option("--status <status>", "status: draft, manual, trigger, scheduled, cancelled")
+        .option("--persona <id>", "persona ID (empty to clear)")
+        .option("--platform-contents <json>", "per-platform content as JSON string")
+        .option("--dropspace-platforms <list>", "official dropspace account platforms", parseList)
+        .option("--user-accounts <json>", "platform-to-token_id map as JSON string")
+        .option("--media-mode <mode>", "media mode: images or video")
+        .action(async (id, opts) => {
+        try {
+            const body = {};
+            if (opts.name)
+                body.name = opts.name;
+            if (opts.description)
+                body.product_description = opts.description;
+            if (opts.platforms)
+                body.platforms = opts.platforms;
+            if (opts.url !== undefined)
+                body.product_url = opts.url || "";
+            if (opts.schedule !== undefined)
+                body.scheduled_date = opts.schedule || null;
+            if (opts.status)
+                body.status = opts.status;
+            if (opts.persona !== undefined)
+                body.persona_id = opts.persona || null;
+            if (opts.platformContents)
+                body.platform_contents = JSON.parse(opts.platformContents);
+            if (opts.dropspacePlatforms)
+                body.dropspace_platforms = opts.dropspacePlatforms;
+            if (opts.userAccounts)
+                body.user_platform_accounts = JSON.parse(opts.userAccounts);
+            if (opts.mediaMode)
+                body.media_mode = opts.mediaMode;
+            const result = await client.patch(`/launches/${id}`, body);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    launches
+        .command("delete <id>")
+        .description("delete a launch")
+        .action(async (id) => {
+        try {
+            await client.delete(`/launches/${id}`);
+            console.log("launch deleted");
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    launches
+        .command("publish <id>")
+        .description("publish a launch to all configured platforms")
+        .action(async (id) => {
+        try {
+            const result = await client.post(`/launches/${id}/publish`);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    launches
+        .command("retry <id>")
+        .description("retry failed platforms for a launch")
+        .action(async (id) => {
+        try {
+            const result = await client.post(`/launches/${id}/retry`);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    launches
+        .command("generate <id>")
+        .description("generate AI content for a launch")
+        .option("--platforms <list>", "specific platforms to generate for", parseList)
+        .action(async (id, opts) => {
+        try {
+            const body = {};
+            if (opts.platforms)
+                body.platforms = opts.platforms;
+            const result = await client.post(`/launches/${id}/generate-content`, body);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    launches
+        .command("retry-content <id>")
+        .description("retry AI content generation for failed platforms")
+        .option("--platforms <list>", "specific platforms to retry", parseList)
+        .action(async (id, opts) => {
+        try {
+            const body = {};
+            if (opts.platforms)
+                body.platforms = opts.platforms;
+            const result = await client.post(`/launches/${id}/retry-content`, body);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    launches
+        .command("analytics <id>")
+        .description("get launch analytics with per-post engagement metrics")
+        .action(async (id) => {
+        try {
+            const result = await client.get(`/launches/${id}/analytics`);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    launches
+        .command("batch-analytics")
+        .description("get cached analytics for multiple launches")
+        .requiredOption("--ids <list>", "comma-separated launch IDs", parseList)
+        .action(async (opts) => {
+        try {
+            const result = await client.get("/launches/analytics", { ids: opts.ids.join(",") });
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    launches
+        .command("status <id>")
+        .description("get detailed posting status with per-platform logs")
+        .action(async (id) => {
+        try {
+            const result = await client.get(`/launches/${id}/status`);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    launches
+        .command("delete-post <launch-id> <posting-log-id>")
+        .description("delete a single published post from its platform")
+        .action(async (launchId, postingLogId) => {
+        try {
+            await client.delete(`/launches/${launchId}/posts/${postingLogId}`);
+            console.log("post deleted");
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    launches
+        .command("delete-posts <id>")
+        .description("delete all published posts for a launch")
+        .action(async (id) => {
+        try {
+            await client.delete(`/launches/${id}/posts`);
+            console.log("all posts deleted");
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+}

package/dist/commands/personas.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "commander";
+import type { DropspaceClient } from "../client.js";
+export declare function registerPersonaCommands(program: Command, client: DropspaceClient): void;

package/dist/commands/personas.js

@@ -0,0 +1,116 @@
+import { formatOutput, handleError, getFormat, parseList } from "../cli-utils.js";
+export function registerPersonaCommands(program, client) {
+    const personas = program.command("personas").alias("p").description("manage personas");
+    personas
+        .command("list")
+        .description("list personas with pagination")
+        .option("-p, --page <n>", "page number", "1")
+        .option("-s, --page-size <n>", "items per page (max 100)", "50")
+        .action(async (opts) => {
+        try {
+            const params = {};
+            if (opts.page)
+                params.page = opts.page;
+            if (opts.pageSize)
+                params.page_size = opts.pageSize;
+            const result = await client.get("/personas", params);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    personas
+        .command("create")
+        .description("create a new persona")
+        .requiredOption("-n, --name <name>", "persona name")
+        .action(async (opts) => {
+        try {
+            const result = await client.post("/personas", { name: opts.name });
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    personas
+        .command("get <id>")
+        .description("get a persona by ID")
+        .action(async (id) => {
+        try {
+            const result = await client.get(`/personas/${id}`);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    personas
+        .command("update <id>")
+        .description("update a persona")
+        .option("-n, --name <name>", "new persona name")
+        .option("--custom-samples <json>", "custom writing samples as JSON array")
+        .option("--twitter-samples <json>", "twitter writing samples as JSON array")
+        .option("--reddit-samples <json>", "reddit writing samples as JSON array")
+        .option("--facebook-samples <json>", "facebook writing samples as JSON array")
+        .option("--instagram-samples <json>", "instagram writing samples as JSON array")
+        .option("--tiktok-samples <json>", "tiktok writing samples as JSON array")
+        .option("--linkedin-samples <json>", "linkedin writing samples as JSON array")
+        .action(async (id, opts) => {
+        try {
+            const body = {};
+            if (opts.name)
+                body.name = opts.name;
+            if (opts.customSamples)
+                body.custom_samples = JSON.parse(opts.customSamples);
+            if (opts.twitterSamples)
+                body.twitter_samples = JSON.parse(opts.twitterSamples);
+            if (opts.redditSamples)
+                body.reddit_samples = JSON.parse(opts.redditSamples);
+            if (opts.facebookSamples)
+                body.facebook_samples = JSON.parse(opts.facebookSamples);
+            if (opts.instagramSamples)
+                body.instagram_samples = JSON.parse(opts.instagramSamples);
+            if (opts.tiktokSamples)
+                body.tiktok_samples = JSON.parse(opts.tiktokSamples);
+            if (opts.linkedinSamples)
+                body.linkedin_samples = JSON.parse(opts.linkedinSamples);
+            const result = await client.patch(`/personas/${id}`, body);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    personas
+        .command("delete <id>")
+        .description("delete a persona")
+        .action(async (id) => {
+        try {
+            await client.delete(`/personas/${id}`);
+            console.log("persona deleted");
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    personas
+        .command("analyze <id>")
+        .description("trigger AI analysis of a persona's writing style")
+        .option("--platforms <list>", "specific platforms to analyze", parseList)
+        .option("--include-custom", "include custom writing samples")
+        .action(async (id, opts) => {
+        try {
+            const body = {};
+            if (opts.platforms)
+                body.platforms = opts.platforms;
+            if (opts.includeCustom)
+                body.include_custom_samples = true;
+            const result = await client.post(`/personas/${id}/analyze`, body);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+}

package/dist/commands/usage.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "commander";
+import type { DropspaceClient } from "../client.js";
+export declare function registerUsageCommands(program: Command, client: DropspaceClient): void;

package/dist/commands/usage.js

@@ -0,0 +1,15 @@
+import { formatOutput, handleError, getFormat } from "../cli-utils.js";
+export function registerUsageCommands(program, client) {
+    program
+        .command("usage")
+        .description("get current plan, usage limits, and billing period")
+        .action(async () => {
+        try {
+            const result = await client.get("/usage");
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+}

package/dist/commands/webhooks.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "commander";
+import type { DropspaceClient } from "../client.js";
+export declare function registerWebhookCommands(program: Command, client: DropspaceClient): void;

package/dist/commands/webhooks.js

@@ -0,0 +1,108 @@
+import { formatOutput, handleError, getFormat, parseList } from "../cli-utils.js";
+export function registerWebhookCommands(program, client) {
+    const webhooks = program.command("webhooks").alias("w").description("manage webhooks");
+    webhooks
+        .command("list")
+        .description("list webhooks (requires admin scope)")
+        .action(async () => {
+        try {
+            const result = await client.get("/webhooks");
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    webhooks
+        .command("create")
+        .description("create a webhook endpoint (requires admin scope)")
+        .requiredOption("-u, --url <url>", "HTTPS webhook URL")
+        .requiredOption("-e, --events <list>", "comma-separated events: launch.completed,launch.failed,launch.partial,media.ready,persona.analyzed,post.deleted", parseList)
+        .action(async (opts) => {
+        try {
+            const result = await client.post("/webhooks", { url: opts.url, events: opts.events });
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    webhooks
+        .command("get <id>")
+        .description("get a webhook by ID (requires admin scope)")
+        .action(async (id) => {
+        try {
+            const result = await client.get(`/webhooks/${id}`);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    webhooks
+        .command("update <id>")
+        .description("update a webhook (requires admin scope)")
+        .option("-u, --url <url>", "new HTTPS webhook URL")
+        .option("-e, --events <list>", "new events to subscribe to", parseList)
+        .option("--active", "enable the webhook")
+        .option("--no-active", "disable the webhook")
+        .action(async (id, opts) => {
+        try {
+            const body = {};
+            if (opts.url)
+                body.url = opts.url;
+            if (opts.events)
+                body.events = opts.events;
+            if (opts.active !== undefined)
+                body.active = opts.active;
+            const result = await client.patch(`/webhooks/${id}`, body);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    webhooks
+        .command("delete <id>")
+        .description("delete a webhook (requires admin scope)")
+        .action(async (id) => {
+        try {
+            await client.delete(`/webhooks/${id}`);
+            console.log("webhook deleted");
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    webhooks
+        .command("rotate-secret <id>")
+        .description("rotate a webhook's signing secret (requires admin scope)")
+        .action(async (id) => {
+        try {
+            const result = await client.post(`/webhooks/${id}/rotate-secret`);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    webhooks
+        .command("deliveries <id>")
+        .description("list delivery attempts for a webhook (requires admin scope)")
+        .option("-p, --page <n>", "page number", "1")
+        .option("-s, --page-size <n>", "items per page (max 100)", "50")
+        .action(async (id, opts) => {
+        try {
+            const params = {};
+            if (opts.page)
+                params.page = opts.page;
+            if (opts.pageSize)
+                params.page_size = opts.pageSize;
+            const result = await client.get(`/webhooks/${id}/deliveries`, params);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { DropspaceClient } from "./client.js";
+import { registerLaunchTools } from "./tools/launches.js";
+import { registerPersonaTools } from "./tools/personas.js";
+import { registerConnectionTools } from "./tools/connections.js";
+import { registerKeyTools } from "./tools/keys.js";
+import { registerWebhookTools } from "./tools/webhooks.js";
+import { registerDropspaceTools } from "./tools/dropspace.js";
+import { registerUsageTools } from "./tools/usage.js";
+const server = new McpServer({
+    name: "dropspace",
+    version: "2.0.0",
+});
+const client = new DropspaceClient();
+registerLaunchTools(server, client);
+registerPersonaTools(server, client);
+registerConnectionTools(server, client);
+registerKeyTools(server, client);
+registerWebhookTools(server, client);
+registerDropspaceTools(server, client);
+registerUsageTools(server, client);
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/tools/connections.d.ts

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

package/dist/tools/connections.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export function registerConnectionTools(server, client) {
+    server.tool("list_connections", "list your connected social media accounts", {
+        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("/connections", 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/tools/dropspace.d.ts

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

package/dist/tools/dropspace.js

@@ -0,0 +1,21 @@
+export function registerDropspaceTools(server, client) {
+    server.tool("get_dropspace_status", "check which platforms have a connected dropspace official account (requires read scope)", {}, async () => {
+        try {
+            const result = await client.get("/dropspace/status");
+            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/keys.d.ts

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