@viralspin/mcp 0.1.0 → 0.2.2

package/dist/tools/video-assembly.js

@@ -0,0 +1,310 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVideoAssemblyTool = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const client_js_1 = require("../client.js");
+const hosted_js_1 = require("../hosted.js");
+const engine_js_1 = require("../engine.js");
+const MEDIA_EXT = new Set([".mp4", ".mov", ".webm", ".m4v", ".jpg", ".jpeg", ".png", ".gif", ".webp"]);
+/** Split B-roll entries into local files (expanding folders) and public URLs.
+ *  Runs on the MCP host, so it can read the user's disk to expand a folder. */
+function partitionBroll(entries) {
+    const localFiles = [];
+    const urls = [];
+    for (const e of entries) {
+        if (/^https?:\/\//i.test(e)) {
+            urls.push(e);
+            continue;
+        }
+        try {
+            const st = fs_1.default.statSync(e);
+            if (st.isDirectory()) {
+                for (const name of fs_1.default.readdirSync(e)) {
+                    if (MEDIA_EXT.has(path_1.default.extname(name).toLowerCase()))
+                        localFiles.push(path_1.default.join(e, name));
+                }
+            }
+            else if (st.isFile()) {
+                localFiles.push(e);
+            }
+        }
+        catch { /* unreadable path — skip */ }
+    }
+    return { localFiles, urls };
+}
+const VIDEO_EXT = /\.(mp4|mov|webm|m4v)(\?|$)/i;
+function brollKind(url) {
+    return VIDEO_EXT.test(url) ? "video" : "image";
+}
+const BROLL_STYLE_KEYS = ["sketchbook", "cinematic_minimal", "dark_studio", "vibrant_illustrated"];
+const CAPTION_STYLE_KEYS = ["auto", "default", "hormozi", "glow_neon", "minimalist", "whiteboard"];
+/** Baked template recipes (mirrors src/data/videoTemplates.ts). Selecting one from
+ *  the gallery seeds these defaults so the user doesn't describe the style. */
+const VIDEO_TEMPLATES = {
+    screen_demo: {
+        output_format: "9x16",
+        caption_style: "hormozi",
+        direction: "Screen-demo style: fast caption-driven cuts on the beat, punch-in zoom to exactly where the on-screen " +
+            "action is each cut, meme captions, brand end card.",
+    },
+};
+/** Run the engine orchestrator, streaming its logs to stderr, and capture RESULT:<path>. */
+function runEngine(args, extraEnv = {}) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(process.platform === "win32" ? "node.exe" : "node", [path_1.default.join(engine_js_1.ENGINE_DIR, "assemble.mjs"), ...args], { cwd: engine_js_1.ENGINE_DIR, env: { ...process.env, ...extraEnv } });
+        let stdout = "";
+        child.stdout.on("data", (d) => { stdout += d.toString(); });
+        child.stderr.on("data", (d) => process.stderr.write(d)); // progress → MCP server log
+        child.on("error", reject);
+        child.on("close", (code) => {
+            const m = stdout.match(/RESULT:(.+)/);
+            if (code === 0 && m)
+                resolve(m[1].trim());
+            else
+                reject(new Error(`Assembly engine exited ${code}. ${stdout.slice(-400)}`));
+        });
+    });
+}
+exports.createVideoAssemblyTool = {
+    name: "create_video_assembly",
+    description: "Turn an A-roll talking-head/performance clip into a polished vertical (9:16) short by editing in B-roll cutaways. " +
+        "Runs a LOCAL pipeline: transcribes the A-roll, finds each B-roll's focal point (face/subject-aware so nothing is cropped off), " +
+        "matches B-roll to what's being said, and renders with Ken Burns motion + the speaker's voice as the soundtrack (B-roll clip audio is mixed in as a low faded bed). " +
+        "Accepts LOCAL file paths OR public URLs for both A-roll and B-roll, and a B-roll FOLDER is expanded automatically. " +
+        "Pass style_ref (a reference video) to AUTO-INFER the editing style from it — captions, hook headline, keyword pops, pace, and aspect ratio — so you don't have to describe them. " +
+        "Returns the path to the finished MP4, which you can then publish with publish_now / schedule_post.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            aroll: {
+                type: "string",
+                description: "A-roll source: a local file path (e.g. C:/clips/talk.mp4) OR a public video URL.",
+            },
+            broll: {
+                type: "array",
+                items: { type: "string" },
+                description: "Optional B-roll sources: local file paths, a local FOLDER (expanded to its images/videos), and/or public URLs. " +
+                    "Mix freely. Omit for an A-roll-only edit (just motion, no cutaways).",
+            },
+            prompt: {
+                type: "string",
+                description: "Optional creative direction for the edit (mood, what to emphasise, pacing).",
+            },
+            output_format: {
+                type: "string",
+                enum: ["9x16", "1x1", "16x9"],
+                description: "Aspect ratio. Default 9x16 (vertical for Reels/TikTok/Shorts).",
+            },
+            out: {
+                type: "string",
+                description: "Optional output MP4 path. Defaults to the engine's out/ folder.",
+            },
+            google_picker_session: {
+                type: "string",
+                description: "Optional sessionId from start_photo_picker. If set, the photos/clips you picked in Google Photos are ingested as B-roll (in addition to any `broll`).",
+            },
+            style_ref: {
+                type: "string",
+                description: "Optional reference video (local path or URL). The tool watches it and infers the edit style — captions on/off + style, hook headline, keyword pops, cut pace, and aspect ratio — and applies it automatically. Overrides output_format when set.",
+            },
+            broll_mode: {
+                type: "string",
+                enum: ["user_provided", "ai_generated"],
+                description: "B-roll source mode. 'user_provided' (default) = use local files or Google Photos. 'ai_generated' = AI reads the transcript and generates stylized cinematic B-roll images — no local footage needed. Requires the 'style' param.",
+            },
+            destination: {
+                type: "string",
+                enum: ["local", "hosted"],
+                description: "Where the project lives. 'local' (default) = render on this machine, return an MP4 path (no upload; reads local disk). " +
+                    "'hosted' = create a Swap & Refine project on the user's ViralSpin account: local A-roll/B-roll are uploaded, the project " +
+                    "opens in the web editor, and follow-up swap_clip/suggest_clips (with its job_id) drive that same project. Use 'hosted' " +
+                    "when the user wants to refine in the browser or keep the project in their account.",
+            },
+            style: {
+                type: "string",
+                enum: BROLL_STYLE_KEYS,
+                description: "Style anchor for AI-generated B-roll (required when broll_mode='ai_generated'). " +
+                    "sketchbook = hand-drawn ink on graph paper; " +
+                    "cinematic_minimal = flat-lay dark surface, warm tungsten lamp; " +
+                    "dark_studio = matte black workspace, designer aesthetic; " +
+                    "vibrant_illustrated = bold pop-art flat illustration.",
+            },
+            explainer_index_id: {
+                type: "string",
+                description: "Optional Twelve Labs index ID returned by index_explainer_sources. " +
+                    "When set, long-form videos (>2 min) in the broll folder are searched semantically " +
+                    "instead of being clipped from their start. Requires TWELVE_LABS_API_KEY in the MCP env.",
+            },
+            template: {
+                type: "string",
+                enum: ["screen_demo"],
+                description: "Optional baked template (from the preview-and-select gallery). 'screen_demo' = the viral build-in-public " +
+                    "product-demo style: 9x16, fast beat-synced cuts, punch-in zoom to the on-screen action, meme captions, brand " +
+                    "end card. Seeds output_format + caption_style + creative direction so you don't describe the style; combine " +
+                    "with find_moments mode:'screen' snippets as the footage.",
+            },
+            caption_style: {
+                type: "string",
+                enum: CAPTION_STYLE_KEYS,
+                description: "Caption style. Default 'auto' = AI picks the best style from the transcript. " +
+                    "default = bold white spring pop-in. " +
+                    "hormozi = word-by-word yellow highlight (high-energy talking-head). " +
+                    "glow_neon = neon cyan pulsing text (dark aesthetic, music, gaming). " +
+                    "minimalist = lowercase thin font fade-in (calm, educational). " +
+                    "whiteboard = left-to-right text reveal (explainers, tutorials). " +
+                    "After rendering, change it instantly with swap_caption_style.",
+            },
+        },
+        required: ["aroll"],
+    },
+    async execute(args) {
+        // Baked template selected in the gallery → seed its recipe defaults (user's
+        // explicit args always win). The style intent rides `prompt`; the beat-grid +
+        // preset audio live engine-side (VIRALSPIN_VIDEO_TEMPLATE), consumed by the
+        // screen-demo assembly path.
+        if (args.template && VIDEO_TEMPLATES[args.template]) {
+            const t = VIDEO_TEMPLATES[args.template];
+            args.output_format = args.output_format ?? t.output_format;
+            args.caption_style = args.caption_style ?? t.caption_style;
+            args.prompt = args.prompt ? `${t.direction}\n${args.prompt}` : t.direction;
+        }
+        // AI-generated B-roll mode: delegate to the cloud narrative pipeline.
+        if (args.broll_mode === "ai_generated") {
+            if (!args.style) {
+                return "Error: 'style' is required when broll_mode='ai_generated'. Choose one of: sketchbook, cinematic_minimal, dark_studio, vibrant_illustrated.";
+            }
+            const job = await (0, client_js_1.post)("/v1/narrative/jobs", {
+                aroll_paths: [args.aroll],
+                prompt: args.prompt,
+                output_format: args.output_format ?? "9x16",
+                broll_mode: "ai_generated",
+                style_anchor: args.style,
+            });
+            const deadline = Date.now() + 15 * 60 * 1000;
+            let result = { status: "queued" };
+            while (Date.now() < deadline) {
+                await new Promise((r) => setTimeout(r, 6000));
+                result = await (0, client_js_1.get)(`/v1/narrative/jobs/${job.job_id}`);
+                if (result.status === "complete" || result.status === "failed")
+                    break;
+            }
+            if (result.status === "failed")
+                return `Assembly failed: ${result.error_message ?? "unknown error"}`;
+            if (result.status !== "complete")
+                return `Assembly timed out. Job ID: ${job.job_id} — check the dashboard.`;
+            return (`AI B-roll assembly complete (style: ${args.style}).\n` +
+                `Preview: ${result.preview_url ?? "—"}\n` +
+                `Download: ${result.download_url ?? "—"}\n` +
+                `Publish it with publish_now or schedule_post.`);
+        }
+        // Hosted project: create a Swap & Refine project (narrative job) on the
+        // user's account instead of rendering locally. Local files are uploaded to
+        // public URLs, then the web editor + the hosted swap_clip/suggest_clips verbs
+        // take over. This is the path that "merges" Claude with the web platform.
+        if (args.destination === "hosted") {
+            // Upload the A-roll (local path → public URL). A URL passes straight through.
+            const arollUrl = /^https?:\/\//i.test(args.aroll)
+                ? args.aroll
+                : (await (0, client_js_1.uploadFiles)([args.aroll])).urls[0];
+            // Resolve local B-roll (expand folders, upload files) + keep URL B-roll.
+            const { localFiles, urls } = partitionBroll(args.broll ?? []);
+            const uploadedUrls = localFiles.length ? (await (0, client_js_1.uploadFiles)(localFiles)).urls : [];
+            const brollItems = [...uploadedUrls, ...urls].map((url) => ({ url, kind: brollKind(url) }));
+            // Create the project. NOTE (verified against the live backend): a hosted
+            // user_provided job picks its INITIAL B-roll from the user's synced library
+            // / Google Photos picker — NOT from ad-hoc local files. (Contextual
+            // selection over an arbitrary local folder is the LOCAL engine's job.) So
+            // local/URL B-roll here is attached as a refine pool the editor + the
+            // swap verbs draw from, once the timeline is built.
+            const job = await (0, client_js_1.post)("/v1/narrative/jobs", {
+                aroll_paths: [arollUrl],
+                prompt: args.prompt,
+                output_format: args.output_format ?? "9x16",
+                broll_mode: "user_provided",
+                ...(args.template ? { template: args.template } : {}),
+                ...(args.google_picker_session ? { picker_session_id: args.google_picker_session } : {}),
+            });
+            // Attach local/URL B-roll once the build produces a timeline (the uploads
+            // endpoint 409s before then). Best-effort + bounded so we don't hang.
+            let attachNote = "";
+            if (brollItems.length) {
+                const r = await (0, hosted_js_1.attachUploadsWhenReady)(job.job_id, brollItems);
+                attachNote = r.attached
+                    ? `Attached ${brollItems.length} local/URL B-roll source(s) to the project's refine pool.\n`
+                    : `Queued ${brollItems.length} local/URL B-roll source(s), but they weren't attached yet (${r.detail}); add them in the editor's Upload tab.\n`;
+            }
+            const creditNote = job.credits_charged != null ? `Charged ${job.credits_charged} credits (${job.credits_remaining} left).\n` : "";
+            return (`Created a hosted Swap & Refine project (job ${job.job_id}).\n` +
+                creditNote +
+                `Open / refine it in the editor: ${(0, hosted_js_1.editorUrl)(job.job_id)}\n` +
+                attachNote +
+                (args.google_picker_session ? "" : "Heads up: initial B-roll is picked from your synced library / Google Photos — pass a Google Photos picker session for richer hosted B-roll.\n") +
+                `From here: suggest_clips(job_id: "${job.job_id}") to see the cutaways, then ` +
+                `swap_clip(job_id: "${job.job_id}", …) to change one — edits show up live in the editor.\n` +
+                `Tip: set VIRALSPIN_HOSTED_JOB_ID=${job.job_id} to make the swap verbs target this project by default.`);
+        }
+        // Local assembly shells out to the bundled engine. The public npm package
+        // ships WITHOUT it (the closed magic), so route the user to the hosted cloud
+        // pipeline instead of failing with an opaque spawn error.
+        if (!(0, engine_js_1.engineAvailable)()) {
+            return ("Local video assembly needs the ViralSpin engine, which isn't bundled in this install.\n" +
+                "Use the cloud pipeline instead: call create_video_assembly again with destination: \"hosted\" " +
+                "— it renders in the cloud and opens in the web Swap & Refine editor.\n" +
+                "(Advanced: set VIRALSPIN_ASSEMBLY_DIR to a local engine checkout to enable local rendering.)");
+        }
+        const broll = [...(args.broll ?? [])];
+        // Pull in Google Photos picks (re-hosted to public URLs by the backend), if any.
+        if (args.google_picker_session) {
+            const r = await (0, client_js_1.get)(`/v1/assembly/picker?sessionId=${encodeURIComponent(args.google_picker_session)}`);
+            if (r.status !== "ready") {
+                return "Your Google Photos picks aren't ready yet — finish selecting in the picker tab, then run create_video_assembly again with the same google_picker_session.";
+            }
+            for (const it of r.items ?? [])
+                broll.push(it.url);
+        }
+        const cli = ["--aroll", args.aroll];
+        if (broll.length)
+            cli.push("--broll", ...broll);
+        if (args.prompt)
+            cli.push("--prompt", args.prompt);
+        if (args.style_ref)
+            cli.push("--style-ref", args.style_ref);
+        if (args.output_format)
+            cli.push("--format", args.output_format);
+        if (args.out)
+            cli.push("--out", args.out);
+        if (args.caption_style && args.caption_style !== "auto")
+            cli.push("--caption-style", args.caption_style);
+        // Pull the admin-managed "secret sauce" prompts (LLM Prompt Store →
+        // LOCAL VIDEO ASSEMBLY section) and hand them to the engine. Best-effort:
+        // on any failure the engine falls back to its built-in prompts.
+        const extraEnv = {};
+        try {
+            const r = await (0, client_js_1.get)("/v1/assembly/prompts");
+            if (r.prompts && Object.keys(r.prompts).length) {
+                extraEnv.VIRALSPIN_ASSEMBLY_PROMPTS = JSON.stringify(r.prompts);
+            }
+        }
+        catch { /* engine uses built-in prompts */ }
+        if (args.explainer_index_id) {
+            extraEnv.EXPLAINER_INDEX_ID = args.explainer_index_id;
+        }
+        if (process.env.TWELVE_LABS_API_KEY) {
+            extraEnv.TWELVE_LABS_API_KEY = process.env.TWELVE_LABS_API_KEY;
+        }
+        if (args.template) {
+            // Engine reads this to apply the baked recipe (beat grid + preset audio +
+            // punch-in) in the screen-demo assembly path.
+            extraEnv.VIRALSPIN_VIDEO_TEMPLATE = args.template;
+        }
+        const outPath = await runEngine(cli, extraEnv);
+        return (`Video assembly complete.\n` +
+            `Output: ${outPath}\n` +
+            `Publish it with publish_now (paths: ["${outPath}"]) or schedule_post.`);
+    },
+};

package/package.json

@@ -1,18 +1,30 @@
 {
   "name": "@viralspin/mcp",
-  "version": "0.1.0",
+  "version": "0.2.2",
   "description": "ViralSpin MCP server — publish local videos and carousels to TikTok, Instagram, and YouTube from Claude Code",
   "main": "dist/index.js",
   "bin": {
     "viralspin-mcp": "dist/index.js"
   },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
     "build": "tsc",
     "dev": "ts-node src/index.ts",
     "start": "node dist/index.js",
     "prepublishOnly": "npm run build"
   },
-  "keywords": ["mcp", "viralspin", "tiktok", "instagram", "youtube", "social-media"],
+  "keywords": [
+    "mcp",
+    "viralspin",
+    "tiktok",
+    "instagram",
+    "youtube",
+    "social-media"
+  ],
   "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",

package/src/client.ts

@@ -1,80 +0,0 @@
-import FormData from "form-data";
-import fs from "fs";
-import path from "path";
-
-const API_URL = (process.env.VIRALSPIN_API_URL || "https://viralspinbackend.onrender.com").replace(/\/$/, "");
-const API_KEY = process.env.VIRALSPIN_API_KEY || "";
-
-if (!API_KEY) {
-  process.stderr.write("[viralspin-mcp] Warning: VIRALSPIN_API_KEY not set\n");
-}
-
-function headers(extra: Record<string, string> = {}): Record<string, string> {
-  return { "X-API-Key": API_KEY, ...extra };
-}
-
-async function apiFetch<T>(endpoint: string, init: RequestInit = {}): Promise<T> {
-  const url = `${API_URL}${endpoint}`;
-  const resp = await fetch(url, {
-    ...init,
-    headers: { ...(init.headers as Record<string, string> ?? {}), ...headers() },
-  });
-  if (!resp.ok) {
-    const text = await resp.text().catch(() => "");
-    let detail = text;
-    try { detail = JSON.parse(text).detail ?? text; } catch {}
-    throw new Error(`API error ${resp.status}: ${detail}`);
-  }
-  return resp.json() as Promise<T>;
-}
-
-export function get<T>(endpoint: string): Promise<T> {
-  return apiFetch<T>(endpoint, { method: "GET" });
-}
-
-export function post<T>(endpoint: string, body: unknown): Promise<T> {
-  return apiFetch<T>(endpoint, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(body),
-  });
-}
-
-export function del<T>(endpoint: string, body?: unknown): Promise<T> {
-  return apiFetch<T>(endpoint, {
-    method: "DELETE",
-    headers: body ? { "Content-Type": "application/json" } : {},
-    body: body ? JSON.stringify(body) : undefined,
-  });
-}
-
-/** Upload one or more local files. Returns { url, storage_path } or { urls, storage_paths } */
-export async function uploadFiles(filePaths: string[]): Promise<{ urls: string[]; storage_paths: string[] }> {
-  const form = new FormData();
-  const fieldName = filePaths.length === 1 ? "file" : "files";
-  for (const fp of filePaths) {
-    form.append(fieldName, fs.createReadStream(fp), path.basename(fp));
-  }
-
-  const resp = await fetch(`${API_URL}/v1/media/upload`, {
-    method: "POST",
-    headers: { "X-API-Key": API_KEY, ...form.getHeaders() },
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    body: form as any,
-  });
-  if (!resp.ok) {
-    const text = await resp.text().catch(() => "");
-    let detail = text;
-    try { detail = JSON.parse(text).detail ?? text; } catch {}
-    throw new Error(`Upload failed ${resp.status}: ${detail}`);
-  }
-  const data = await resp.json() as { url?: string; storage_path?: string; urls?: string[]; storage_paths?: string[] };
-  if (data.urls) return { urls: data.urls, storage_paths: data.storage_paths! };
-  return { urls: [data.url!], storage_paths: [data.storage_path!] };
-}
-
-/** Delete uploaded files from storage (cleanup after publish) */
-export async function deleteFiles(storagePaths: string[]): Promise<void> {
-  if (!storagePaths.length) return;
-  await del(`/v1/media/${storagePaths[0]}`, storagePaths.length > 1 ? { storage_paths: storagePaths } : undefined);
-}

package/src/index.ts

@@ -1,60 +0,0 @@
-#!/usr/bin/env node
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-
-import { listConnectionsTool } from "./tools/connections.js";
-import { publishNowTool, schedulePostTool } from "./tools/publish.js";
-import { listPostsTool, cancelPostTool } from "./tools/posts.js";
-import { generateCaptionTool } from "./tools/captions.js";
-
-const tools = [
-  listConnectionsTool,
-  publishNowTool,
-  schedulePostTool,
-  listPostsTool,
-  cancelPostTool,
-  generateCaptionTool,
-];
-
-const server = new Server(
-  { name: "viralspin", version: "0.1.0" },
-  { capabilities: { tools: {} } }
-);
-
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: tools.map((t) => ({
-    name: t.name,
-    description: t.description,
-    inputSchema: t.inputSchema,
-  })),
-}));
-
-server.setRequestHandler(CallToolRequestSchema, async (req) => {
-  const tool = tools.find((t) => t.name === req.params.name);
-  if (!tool) {
-    return { content: [{ type: "text", text: `Unknown tool: ${req.params.name}` }], isError: true };
-  }
-
-  try {
-    const result = await tool.execute(req.params.arguments as never);
-    return { content: [{ type: "text", text: String(result) }] };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { content: [{ type: "text", text: `Error: ${msg}` }], isError: true };
-  }
-});
-
-async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  process.stderr.write("[viralspin-mcp] Server started\n");
-}
-
-main().catch((err) => {
-  process.stderr.write(`[viralspin-mcp] Fatal: ${err}\n`);
-  process.exit(1);
-});

package/src/tools/captions.ts

@@ -1,32 +0,0 @@
-import { post } from "../client.js";
-
-interface CaptionResponse {
-  caption: string;
-  hashtags: string[];
-}
-
-export const generateCaptionTool = {
-  name: "generate_caption",
-  description: "Generate an AI caption and hashtags for a post on a specific platform.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      title: { type: "string", description: "Video or content title/description." },
-      platform: {
-        type: "string",
-        enum: ["tiktok", "instagram", "youtube"],
-        description: "Target platform.",
-      },
-    },
-    required: ["title", "platform"],
-  },
-
-  async execute(args: { title: string; platform: string }) {
-    const data = await post<CaptionResponse>("/v1/publish/generate-caption", {
-      video_title: args.title,
-      platform: args.platform,
-    });
-    const tags = data.hashtags.map((h) => `#${h.replace(/^#/, "")}`).join(" ");
-    return `Caption:\n${data.caption}\n\nHashtags:\n${tags}`;
-  },
-};

package/src/tools/connections.ts

@@ -1,27 +0,0 @@
-import { get } from "../client.js";
-
-interface Connection {
-  id: string;
-  platform: string;
-  display_name: string;
-  username: string;
-  follower_count: number;
-  is_active: boolean;
-  connected_at: string;
-}
-
-export const listConnectionsTool = {
-  name: "list_connections",
-  description: "List your connected social media accounts (TikTok, Instagram, YouTube).",
-  inputSchema: { type: "object", properties: {}, required: [] },
-
-  async execute(_args: Record<string, unknown>) {
-    const connections = await get<Connection[]>("/v1/publish/connections");
-    if (!connections.length) {
-      return "No platforms connected yet. Visit https://www.viralspin.ai/spin/settings to connect your accounts.";
-    }
-    return connections
-      .map((c) => `${c.platform}: ${c.display_name} (${c.username}) — ${c.follower_count.toLocaleString()} followers`)
-      .join("\n");
-  },
-};

package/src/tools/posts.ts

@@ -1,58 +0,0 @@
-import { get, del } from "../client.js";
-
-interface ScheduledPost {
-  id: string;
-  platforms: string[];
-  caption: string;
-  status: string;
-  scheduled_time: string;
-  published_at: string | null;
-  failed_reason: string | null;
-  media_type: string;
-}
-
-export const listPostsTool = {
-  name: "list_posts",
-  description: "List your scheduled, published, or failed posts.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      status: {
-        type: "string",
-        enum: ["pending", "published", "cancelled", "failed"],
-        description: "Filter by status. Omit to list all posts.",
-      },
-    },
-    required: [],
-  },
-
-  async execute(args: { status?: string }) {
-    const qs = args.status ? `?status=${args.status}` : "";
-    const posts = await get<ScheduledPost[]>(`/v1/publish/posts${qs}`);
-    if (!posts.length) return "No posts found.";
-    return posts
-      .map((p) => {
-        const time = p.published_at ?? p.scheduled_time;
-        const label = p.published_at ? "published" : "scheduled";
-        return `[${p.id.slice(0, 8)}] ${p.status.toUpperCase()} — ${p.platforms.join("+")} ${p.media_type} | ${label}: ${time}\n  "${p.caption?.slice(0, 60)}${(p.caption?.length ?? 0) > 60 ? "…" : ""}"${p.failed_reason ? `\n  Error: ${p.failed_reason}` : ""}`;
-      })
-      .join("\n\n");
-  },
-};
-
-export const cancelPostTool = {
-  name: "cancel_post",
-  description: "Cancel a pending scheduled post by ID.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      post_id: { type: "string", description: "The post ID to cancel." },
-    },
-    required: ["post_id"],
-  },
-
-  async execute(args: { post_id: string }) {
-    await del(`/v1/publish/posts/${args.post_id}`);
-    return `Post ${args.post_id} cancelled.`;
-  },
-};