@jclvsh/dropspace 2.10.0 → 2.11.0

package/README.md

@@ -1,6 +1,6 @@
 # @jclvsh/dropspace
 
-MCP server and CLI for the [Dropspace](https://www.dropspace.dev) API. Lets AI agents (Claude Code, Cursor) and humans manage launches, personas, media generation, boosts, autopilot, recommendations, platform connections, API keys, and webhooks. 59 tools across 13 categories.
+MCP server and CLI for the [Dropspace](https://www.dropspace.dev) API. Lets AI agents (Claude Code, Cursor) and humans manage launches, personas, media generation, boosts, autopilot, recommendations, reddit engagement, platform connections, API keys, and webhooks. 69 tools across 14 categories.
 
 ## Installation
 
@@ -49,6 +49,7 @@ dropspace launches --help
 | media       | generate, job                                                                                                                             | 2     |
 | connections | list                                                                                                                                      | 1     |
 | boosts      | create, list, get, activate, cancel, performance                                                                                          | 6     |
+| reddit      | suggest, config, configure, discover, comments, approve, reject, standing, activate, deactivate                                          | 10    |
 | credits     | balance, purchase                                                                                                                         | 2     |
 | keys        | me, list, create, rename, revoke, rotate                                                                                                  | 6     |
 | webhooks    | list, create, get, update, delete, test, rotate-secret, deliveries                                                                        | 8     |

package/dist/cli.js

@@ -14,6 +14,7 @@ import { registerUsageCommands } from "./commands/usage.js";
 import { registerCreditCommands } from "./commands/credits.js";
 import { registerMediaCommands } from "./commands/media.js";
 import { registerBoostCommands } from "./commands/boosts.js";
+import { registerRedditCommands } from "./commands/reddit.js";
 import { registerAutopilotCommands } from "./commands/autopilot.js";
 import { registerRecommendationCommands } from "./commands/recommendations.js";
 const program = new Command()
@@ -36,6 +37,7 @@ try {
     registerBoostCommands(program, client);
     registerAutopilotCommands(program, client);
     registerRecommendationCommands(program, client);
+    registerRedditCommands(program, client);
     await program.parseAsync(process.argv);
 }
 catch (error) {

package/dist/client.d.ts

@@ -4,6 +4,7 @@ export declare class DropspaceClient {
     constructor();
     get<T>(path: string, params?: Record<string, string>): Promise<T>;
     post<T>(path: string, body?: unknown): Promise<T>;
+    put<T>(path: string, body: unknown): Promise<T>;
     patch<T>(path: string, body: unknown): Promise<T>;
     delete(path: string): Promise<void>;
     private request;

package/dist/client.js

@@ -31,6 +31,13 @@ export class DropspaceClient {
             body: body !== undefined ? JSON.stringify(body) : undefined,
         });
     }
+    async put(path, body) {
+        return this.request(`${this.baseUrl}${path}`, {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+    }
     async patch(path, body) {
         return this.request(`${this.baseUrl}${path}`, {
             method: "PATCH",

package/dist/commands/reddit.d.ts

@@ -0,0 +1,8 @@
+import type { Command } from "commander";
+import type { DropspaceClient } from "../client.js";
+/**
+ * Reddit discovery + engagement CLI — the earn-standing-before-promoting loop:
+ * suggest → activate → discover → approve/reject → standing. Requires an api key whose
+ * account has reddit connected; caps and gates are enforced server-side (hard rails).
+ */
+export declare function registerRedditCommands(program: Command, client: DropspaceClient): void;

package/dist/commands/reddit.js

@@ -0,0 +1,146 @@
+import { formatOutput, handleError, getFormat } from "../cli-utils.js";
+/**
+ * Reddit discovery + engagement CLI — the earn-standing-before-promoting loop:
+ * suggest → activate → discover → approve/reject → standing. Requires an api key whose
+ * account has reddit connected; caps and gates are enforced server-side (hard rails).
+ */
+export function registerRedditCommands(program, client) {
+    const reddit = program.command("reddit").description("subreddit discovery + engagement (earn standing before promoting)");
+    reddit
+        .command("suggest")
+        .description("ICP-matched subreddit discovery with per-community standing badges")
+        .requiredOption("-b, --brief <text>", "what the product is and who it's for (10-2000 chars)")
+        .action(async (opts) => {
+        try {
+            const result = await client.post("/reddit/subreddits/suggest", { brief: opts.brief });
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    reddit
+        .command("config")
+        .description("read the engagement settings (enabled, caps, gate state, comment voice)")
+        .action(async () => {
+        try {
+            const result = await client.get("/reddit/engagement/config");
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    reddit
+        .command("configure")
+        .description("enable/disable engagement and tune caps (values above the rails are clamped)")
+        .requiredOption("--enabled <bool>", "true | false")
+        .option("--max-per-day <n>", "daily comment cap (clamped to 5)")
+        .option("--max-per-sub <n>", "per-subreddit daily cap (clamped to 2)")
+        .option("--min-gap <minutes>", "minimum gap between comments (floored at 20)")
+        .option("--persona-id <uuid|null>", "persona whose voice drafts the comments; 'null' = auto (latest)")
+        .action(async (opts) => {
+        try {
+            const body = { enabled: opts.enabled === "true" };
+            if (opts.maxPerDay)
+                body.max_comments_per_day = parseInt(opts.maxPerDay, 10);
+            if (opts.maxPerSub)
+                body.max_comments_per_sub_per_day = parseInt(opts.maxPerSub, 10);
+            if (opts.minGap)
+                body.min_gap_minutes = parseInt(opts.minGap, 10);
+            if (opts.personaId)
+                body.persona_id = opts.personaId === "null" ? null : opts.personaId;
+            const result = await client.put("/reddit/engagement/config", body);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    reddit
+        .command("discover")
+        .description("draft helpful comments for one active subreddit (posts nothing — fills the review queue)")
+        .action(async () => {
+        try {
+            const result = await client.post("/reddit/engagement/discover");
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    reddit
+        .command("comments")
+        .description("list drafted/posted engagement comments")
+        .option("--status <status>", "pending (review queue, default) | history")
+        .action(async (opts) => {
+        try {
+            const result = await client.get("/reddit/engagement/comments", opts.status ? { status: opts.status } : undefined);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    reddit
+        .command("approve <comment-id>")
+        .description("approve a drafted comment — POSTS it into a pacing slot (caps/gaps still enforced)")
+        .option("--body <text>", "edited comment text (replaces the draft)")
+        .action(async (commentId, opts) => {
+        try {
+            const result = await client.post(`/reddit/engagement/comments/${commentId}/approve`, opts.body ? { body: opts.body } : undefined);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    reddit
+        .command("reject <comment-id>")
+        .description("discard a drafted comment without posting")
+        .action(async (commentId) => {
+        try {
+            const result = await client.post(`/reddit/engagement/comments/${commentId}/reject`);
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    reddit
+        .command("standing")
+        .description("earned standing per subreddit (tier, comments, karma, any removal pause)")
+        .action(async () => {
+        try {
+            const result = await client.get("/reddit/engagement/standing");
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    reddit
+        .command("activate <subreddit>")
+        .description("activate a subreddit as an engagement candidate (you pick the communities)")
+        .action(async (subreddit) => {
+        try {
+            const result = await client.post("/reddit/engagement/subreddits", { subreddit });
+            formatOutput(result, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    reddit
+        .command("deactivate <subreddit>")
+        .description("stop drafting comments for a subreddit (earned standing is kept)")
+        .action(async (subreddit) => {
+        try {
+            await client.delete(`/reddit/engagement/subreddits/${encodeURIComponent(subreddit)}`);
+            formatOutput({ subreddit, engagement_enabled: false }, getFormat(program.opts()));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+}

package/dist/index.js

@@ -14,6 +14,7 @@ import { registerMediaTools } from "./tools/media.js";
 import { registerBoostTools } from "./tools/boosts.js";
 import { registerAutopilotTools } from "./tools/autopilot.js";
 import { registerRecommendationTools } from "./tools/recommendations.js";
+import { registerRedditTools } from "./tools/reddit.js";
 const server = new McpServer({
     name: "dropspace",
     version: "2.9.0",
@@ -31,5 +32,6 @@ registerMediaTools(server, client);
 registerBoostTools(server, client);
 registerAutopilotTools(server, client);
 registerRecommendationTools(server, client);
+registerRedditTools(server, client);
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/dist/tools/reddit.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Reddit engagement + discovery MCP tools.
+ *
+ * The full loop an agent runs to earn standing before promoting (reddit's 90:10 norm):
+ * suggest ICP subreddits → activate the relevant ones → discover (drafts helpful comments) →
+ * approve/reject within the hard rails → standing grows → launch fan-out posts clear the
+ * publish-time 90:10 gate. Requires an api key whose account has reddit connected.
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { DropspaceClient } from "../client.js";
+export declare function registerRedditTools(server: McpServer, client: DropspaceClient): void;

package/dist/tools/reddit.js

@@ -0,0 +1,124 @@
+/**
+ * Reddit engagement + discovery MCP tools.
+ *
+ * The full loop an agent runs to earn standing before promoting (reddit's 90:10 norm):
+ * suggest ICP subreddits → activate the relevant ones → discover (drafts helpful comments) →
+ * approve/reject within the hard rails → standing grows → launch fan-out posts clear the
+ * publish-time 90:10 gate. Requires an api key whose account has reddit connected.
+ */
+import { z } from "zod";
+const subredditParam = z
+    .string()
+    .min(3)
+    .describe("community name, no r/ prefix (canonicalized to lowercase server-side)");
+const commentIdParam = z.string().uuid().describe("engagement comment ID (from list_engagement_comments)");
+function ok(result) {
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+}
+function fail(error) {
+    return {
+        content: [{ type: "text", text: `error: ${error instanceof Error ? error.message : String(error)}` }],
+        isError: true,
+    };
+}
+export function registerRedditTools(server, client) {
+    server.tool("suggest_subreddits", "ICP-matched subreddit discovery: pass a product brief, get verified real subreddits with a promo-policy classification and a green/yellow/red standing badge for THIS account. prefer green subs; earn standing in yellow ones by commenting before posting.", {
+        brief: z.string().min(10).max(2000).describe("what the product is and who it's for"),
+    }, async (args) => {
+        try {
+            return ok(await client.post("/reddit/subreddits/suggest", args));
+        }
+        catch (error) {
+            return fail(error);
+        }
+    });
+    server.tool("get_engagement_config", "read the account's reddit engagement settings — enabled, caps, the 14d/50-karma gate state, and which persona voices the comments.", {}, async () => {
+        try {
+            return ok(await client.get("/reddit/engagement/config"));
+        }
+        catch (error) {
+            return fail(error);
+        }
+    });
+    server.tool("update_engagement_config", "enable/disable reddit engagement and tune caps. caps are STRUCTURAL RAILS: values above the ceilings (5/day, 2/sub/day, 20-min gap) are clamped, not obeyed. persona_id pins which persona voices the comments (null = auto latest).", {
+        enabled: z.boolean().describe("turn engagement on/off for this account"),
+        max_comments_per_day: z.number().int().min(1).max(5).optional().describe("clamped to 5"),
+        max_comments_per_sub_per_day: z.number().int().min(1).max(2).optional().describe("clamped to 2"),
+        min_gap_minutes: z.number().int().min(20).optional().describe("floored at 20"),
+        persona_id: z
+            .string()
+            .uuid()
+            .nullable()
+            .optional()
+            .describe("persona whose voice drafts the comments; null = auto (latest complete persona)"),
+    }, async (args) => {
+        try {
+            return ok(await client.put("/reddit/engagement/config", args));
+        }
+        catch (error) {
+            return fail(error);
+        }
+    });
+    server.tool("discover_engagement", "draft helpful comments for ONE of the account's active subreddits (call again to cover more). fills the review queue; posts NOTHING — approval is the separate, rail-gated step. `skipped` names why nothing ran (kill_switch | not_enabled | gate_not_passed).", {}, async () => {
+        try {
+            return ok(await client.post("/reddit/engagement/discover"));
+        }
+        catch (error) {
+            return fail(error);
+        }
+    });
+    server.tool("list_engagement_comments", "list drafted/posted engagement comments. status=pending (default) is the review queue awaiting approve/reject; status=history is everything already acted on.", {
+        status: z.enum(["pending", "history"]).optional().describe("default: pending"),
+    }, async (args) => {
+        try {
+            return ok(await client.get("/reddit/engagement/comments", args.status ? { status: args.status } : undefined));
+        }
+        catch (error) {
+            return fail(error);
+        }
+    });
+    server.tool("approve_engagement_comment", "approve a drafted comment — this POSTS it (scheduled into a pacing slot). the rails still apply: per-day/per-sub caps and the min-gap return 429 when hit. optional body edits the draft before posting.", {
+        comment_id: commentIdParam,
+        body: z.string().min(20).max(1500).optional().describe("edited comment text (replaces the draft)"),
+    }, async (args) => {
+        try {
+            return ok(await client.post(`/reddit/engagement/comments/${args.comment_id}/approve`, args.body ? { body: args.body } : undefined));
+        }
+        catch (error) {
+            return fail(error);
+        }
+    });
+    server.tool("reject_engagement_comment", "discard a drafted comment without posting.", { comment_id: commentIdParam }, async (args) => {
+        try {
+            return ok(await client.post(`/reddit/engagement/comments/${args.comment_id}/reject`));
+        }
+        catch (error) {
+            return fail(error);
+        }
+    });
+    server.tool("get_engagement_standing", "the standing the account has EARNED per subreddit — tier (none → seedling → active → established), comments posted, karma earned, and any active removal pause. this is what lets fan-out posts clear the 90:10 gate.", {}, async () => {
+        try {
+            return ok(await client.get("/reddit/engagement/standing"));
+        }
+        catch (error) {
+            return fail(error);
+        }
+    });
+    server.tool("activate_engagement_subreddit", "activate a subreddit as an engagement candidate — the seed that lets a fresh account draft its first comments. pick subs from suggest_subreddits; YOU choose the communities, the machine only sustains engagement within them.", { subreddit: subredditParam }, async (args) => {
+        try {
+            return ok(await client.post("/reddit/engagement/subreddits", { subreddit: args.subreddit }));
+        }
+        catch (error) {
+            return fail(error);
+        }
+    });
+    server.tool("deactivate_engagement_subreddit", "stop drafting comments for a subreddit. earned standing is kept, so re-activating later resumes where it left off.", { subreddit: subredditParam }, async (args) => {
+        try {
+            await client.delete(`/reddit/engagement/subreddits/${encodeURIComponent(args.subreddit)}`);
+            return ok({ subreddit: args.subreddit, engagement_enabled: false });
+        }
+        catch (error) {
+            return fail(error);
+        }
+    });
+}

package/dist/types.d.ts

@@ -423,3 +423,69 @@ export interface RecommendationApplyResponse {
     recommendation: Recommendation;
     outcome: RecommendationApplyOutcome;
 }
+export interface SubredditStandingBadge {
+    level: string;
+    tier: string;
+    promo_posts_here: number;
+    contributions_here: number;
+    promo_share: number | null;
+    reasons: string[];
+}
+export interface SubredditSuggestion {
+    name: string;
+    title: string;
+    subscribers: number;
+    over18: boolean;
+    subreddit_type: string;
+    promo_policy: string;
+    promo_evidence: string | null;
+    standing: SubredditStandingBadge;
+    reason: string;
+}
+export interface SubredditSuggestions {
+    icp_summary: string;
+    suggestions: SubredditSuggestion[];
+}
+export interface EngagementConfig {
+    enabled: boolean;
+    max_comments_per_day: number;
+    max_comments_per_sub_per_day: number;
+    min_gap_minutes: number;
+    gate_passed: boolean;
+    account_username: string | null;
+    account_total_karma: number | null;
+    persona_id: string | null;
+}
+export interface EngagementComment {
+    id: string;
+    comment_kind: string;
+    subreddit: string;
+    body: string;
+    status: string;
+    scheduled_for: string | null;
+    comment_permalink: string | null;
+    comment_score: number | null;
+    error_message: string | null;
+    created_at: string;
+    target: {
+        subreddit: string;
+        thread_title: string;
+        thread_url: string;
+        thread_author: string | null;
+        relevance_score: number | null;
+    } | null;
+}
+export interface SubredditStanding {
+    subreddit: string;
+    tier: string;
+    comments_posted: number;
+    comments_removed: number;
+    karma_earned: number;
+    paused_until: string | null;
+    pause_reason: string | null;
+    last_activity_at: string | null;
+}
+export interface EngagementSweepResult {
+    drafted: number;
+    skipped: string | null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jclvsh/dropspace",
-	"version": "2.10.0",
+	"version": "2.11.0",
 	"description": "MCP server and CLI for the Dropspace API",
 	"type": "module",
 	"main": "dist/index.js",