@blitz-planner/mcp-server 0.1.0

package/README.md

@@ -0,0 +1,23 @@
+# Blitz Planner MCP Server
+
+Remote Streamable HTTP MCP server for Blitz Planner.
+
+```sh
+BLITZ_API_BASE_URL=https://api.blitz-planner.com/v1 \
+PORT=8787 \
+blitz-planner-mcp
+```
+
+MCP clients call `POST /mcp` and must send their Blitz API key per request:
+
+```http
+Authorization: Bearer bp_live_...
+```
+
+or:
+
+```http
+x-blitz-api-key: bp_live_...
+```
+
+The server is intentionally multi-user safe: it does not use a shared Blitz API key.

package/dist/auth.d.ts

@@ -0,0 +1,2 @@
+export declare function extractBlitzApiKey(headers: Headers | Record<string, unknown>): string | undefined;
+//# sourceMappingURL=auth.d.ts.map

package/dist/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"AAAA,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,SAAS,CA0BjG"}

package/dist/auth.js

@@ -0,0 +1,21 @@
+export function extractBlitzApiKey(headers) {
+    const getHeader = (name) => {
+        if (headers instanceof Headers) {
+            return headers.get(name) || undefined;
+        }
+        const value = headers[name] ||
+            headers[name.toLowerCase()] ||
+            headers[name.toUpperCase()];
+        if (Array.isArray(value)) {
+            return typeof value[0] === "string" ? value[0] : undefined;
+        }
+        return typeof value === "string" ? value : undefined;
+    };
+    const explicit = getHeader("x-blitz-api-key");
+    if (explicit?.trim()) {
+        return explicit.trim();
+    }
+    const authorization = getHeader("authorization");
+    const match = authorization?.match(/^Bearer\s+(.+)$/i);
+    return match?.[1]?.trim();
+}

package/dist/http.d.ts

@@ -0,0 +1,15 @@
+import { BlitzSdkFactory } from "./tools.js";
+export interface CreateMcpHttpAppOptions {
+    baseUrl?: string;
+    host?: string;
+    allowedHosts?: string[];
+    path?: string;
+    sdkFactory?: BlitzSdkFactory;
+    fetch?: typeof fetch;
+}
+export interface StartMcpHttpServerOptions extends CreateMcpHttpAppOptions {
+    port?: number;
+}
+export declare function createMcpHttpApp(options?: CreateMcpHttpAppOptions): any;
+export declare function startMcpHttpServer(options?: StartMcpHttpServerOptions): any;
+//# sourceMappingURL=http.d.ts.map

package/dist/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../src/http.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAwB,MAAM,YAAY,CAAC;AAEnE,MAAM,WAAW,uBAAuB;IACtC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CACtB;AAED,MAAM,WAAW,yBAA0B,SAAQ,uBAAuB;IACxE,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAaD,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,uBAA4B,GAAG,GAAG,CAwD3E;AAED,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,yBAA8B,OAazE"}

package/dist/http.js

@@ -0,0 +1,73 @@
+import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { extractBlitzApiKey } from "./auth.js";
+import { createBlitzMcpServer } from "./tools.js";
+function writeMcpError(res, status, code, message) {
+    res.status(status).json({
+        jsonrpc: "2.0",
+        error: {
+            code,
+            message,
+        },
+        id: null,
+    });
+}
+export function createMcpHttpApp(options = {}) {
+    const mcpPath = options.path || "/mcp";
+    const app = createMcpExpressApp({
+        host: options.host || "0.0.0.0",
+        allowedHosts: options.allowedHosts,
+    });
+    app.get("/healthz", (_req, res) => {
+        res.json({ ok: true, name: "blitz-planner-mcp" });
+    });
+    app.post(mcpPath, async (req, res) => {
+        const apiKey = extractBlitzApiKey(req.headers);
+        if (!apiKey) {
+            writeMcpError(res, 401, -32001, "Missing Blitz Planner API key.");
+            return;
+        }
+        const server = createBlitzMcpServer({
+            apiKey,
+            baseUrl: options.baseUrl,
+            sdkFactory: options.sdkFactory,
+            fetch: options.fetch,
+        });
+        try {
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: undefined,
+            });
+            await server.connect(transport);
+            await transport.handleRequest(req, res, req.body);
+            res.on("close", () => {
+                void transport.close();
+                void server.close();
+            });
+        }
+        catch (error) {
+            if (!res.headersSent) {
+                writeMcpError(res, 500, -32603, error instanceof Error ? error.message : "Internal MCP server error.");
+            }
+        }
+    });
+    app.get(mcpPath, (_req, res) => {
+        writeMcpError(res, 405, -32000, "Method not allowed.");
+    });
+    app.delete(mcpPath, (_req, res) => {
+        writeMcpError(res, 405, -32000, "Method not allowed.");
+    });
+    return app;
+}
+export function startMcpHttpServer(options = {}) {
+    const port = options.port || Number(process.env.PORT || 8787);
+    const host = options.host || process.env.HOST || "0.0.0.0";
+    const baseUrl = options.baseUrl || process.env.BLITZ_API_BASE_URL;
+    const app = createMcpHttpApp({
+        ...options,
+        host,
+        baseUrl,
+    });
+    return app.listen(port, host, () => {
+        console.log(`Blitz Planner MCP server listening on http://${host}:${port}${options.path || "/mcp"}`);
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { createMcpHttpApp, startMcpHttpServer, type CreateMcpHttpAppOptions, type StartMcpHttpServerOptions } from "./http.js";
+import { createBlitzMcpServer, BLITZ_MCP_TOOL_NAMES } from "./tools.js";
+import { extractBlitzApiKey } from "./auth.js";
+import { assertSafeRemoteUrl, downloadRemoteMedia, isPrivateAddress } from "./media-url.js";
+export { BLITZ_MCP_TOOL_NAMES, assertSafeRemoteUrl, createBlitzMcpServer, createMcpHttpApp, downloadRemoteMedia, extractBlitzApiKey, isPrivateAddress, startMcpHttpServer, type CreateMcpHttpAppOptions, type StartMcpHttpServerOptions, };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAGA,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,KAAK,uBAAuB,EAC5B,KAAK,yBAAyB,EAC/B,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACxE,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EACpB,gBAAgB,EAChB,mBAAmB,EACnB,kBAAkB,EAClB,gBAAgB,EAChB,kBAAkB,EAClB,KAAK,uBAAuB,EAC5B,KAAK,yBAAyB,GAC/B,CAAC"}

package/dist/index.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { resolve } from "node:path";
+import { createMcpHttpApp, startMcpHttpServer, } from "./http.js";
+import { createBlitzMcpServer, BLITZ_MCP_TOOL_NAMES } from "./tools.js";
+import { extractBlitzApiKey } from "./auth.js";
+import { assertSafeRemoteUrl, downloadRemoteMedia, isPrivateAddress, } from "./media-url.js";
+export { BLITZ_MCP_TOOL_NAMES, assertSafeRemoteUrl, createBlitzMcpServer, createMcpHttpApp, downloadRemoteMedia, extractBlitzApiKey, isPrivateAddress, startMcpHttpServer, };
+const isDirectRun = process.argv[1] &&
+    resolve(fileURLToPath(import.meta.url)) === resolve(process.argv[1]);
+if (isDirectRun) {
+    startMcpHttpServer();
+}

package/dist/media-url.d.ts

@@ -0,0 +1,18 @@
+export declare const DEFAULT_MAX_REMOTE_MEDIA_BYTES: number;
+export declare const MAX_REMOTE_MEDIA_BYTES: number;
+export interface DownloadedRemoteMedia {
+    bytes: Uint8Array;
+    filename: string;
+    mimeType: string;
+    size: number;
+}
+export interface DownloadRemoteMediaOptions {
+    fetch?: typeof fetch;
+    maxBytes?: number;
+    filename?: string;
+    mimeType?: string;
+}
+export declare function isPrivateAddress(address: string): boolean;
+export declare function assertSafeRemoteUrl(rawUrl: string): Promise<URL>;
+export declare function downloadRemoteMedia(rawUrl: string, options?: DownloadRemoteMediaOptions): Promise<DownloadedRemoteMedia>;
+//# sourceMappingURL=media-url.d.ts.map

package/dist/media-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-url.d.ts","sourceRoot":"","sources":["../src/media-url.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,8BAA8B,QAAoB,CAAC;AAChE,eAAO,MAAM,sBAAsB,QAAqB,CAAC;AAEzD,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,UAAU,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,0BAA0B;IACzC,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAiCzD;AAED,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAyBtE;AAgDD,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,qBAAqB,CAAC,CA+BhC"}

package/dist/media-url.js

@@ -0,0 +1,116 @@
+import { lookup } from "node:dns/promises";
+import { isIP } from "node:net";
+export const DEFAULT_MAX_REMOTE_MEDIA_BYTES = 100 * 1024 * 1024;
+export const MAX_REMOTE_MEDIA_BYTES = 1024 * 1024 * 1024;
+export function isPrivateAddress(address) {
+    if (address.includes(":")) {
+        const lower = address.toLowerCase();
+        return (lower === "::1" ||
+            lower === "0:0:0:0:0:0:0:1" ||
+            lower.startsWith("fc") ||
+            lower.startsWith("fd") ||
+            lower.startsWith("fe80:") ||
+            lower.startsWith("::ffff:127.") ||
+            lower.startsWith("::ffff:10.") ||
+            lower.startsWith("::ffff:192.168."));
+    }
+    const parts = address.split(".").map(Number);
+    if (parts.length !== 4 || parts.some((part) => Number.isNaN(part))) {
+        return true;
+    }
+    const a = parts[0] ?? -1;
+    const b = parts[1] ?? -1;
+    return (a === 0 ||
+        a === 10 ||
+        a === 127 ||
+        (a === 100 && b >= 64 && b <= 127) ||
+        (a === 169 && b === 254) ||
+        (a === 172 && b >= 16 && b <= 31) ||
+        (a === 192 && b === 168) ||
+        (a === 198 && (b === 18 || b === 19)) ||
+        a >= 224);
+}
+export async function assertSafeRemoteUrl(rawUrl) {
+    const url = new URL(rawUrl);
+    if (url.protocol !== "https:" && url.protocol !== "http:") {
+        throw new Error("Remote media URL must use http or https.");
+    }
+    const hostname = url.hostname.toLowerCase();
+    if (hostname === "localhost" ||
+        hostname.endsWith(".localhost") ||
+        hostname.endsWith(".local")) {
+        throw new Error("Remote media URL cannot target localhost or local network hosts.");
+    }
+    const directIp = isIP(hostname);
+    const addresses = directIp
+        ? [{ address: hostname }]
+        : await lookup(hostname, { all: true, verbatim: true });
+    if (!addresses.length || addresses.some((entry) => isPrivateAddress(entry.address))) {
+        throw new Error("Remote media URL resolves to a private or reserved network address.");
+    }
+    return url;
+}
+function filenameFromUrl(url) {
+    const lastSegment = decodeURIComponent(url.pathname.split("/").filter(Boolean).pop() || "");
+    return lastSegment || "media";
+}
+async function readLimitedBytes(response, maxBytes) {
+    const reader = response.body?.getReader();
+    if (!reader) {
+        const buffer = await response.arrayBuffer();
+        if (buffer.byteLength > maxBytes) {
+            throw new Error(`Remote media exceeds the ${maxBytes} byte limit.`);
+        }
+        return new Uint8Array(buffer);
+    }
+    const chunks = [];
+    let total = 0;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        total += value.byteLength;
+        if (total > maxBytes) {
+            throw new Error(`Remote media exceeds the ${maxBytes} byte limit.`);
+        }
+        chunks.push(value);
+    }
+    const bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+}
+function assertSupportedMimeType(mimeType) {
+    if (!mimeType.startsWith("image/") && !mimeType.startsWith("video/")) {
+        throw new Error(`Remote media MIME type ${mimeType} is not supported.`);
+    }
+}
+export async function downloadRemoteMedia(rawUrl, options = {}) {
+    const url = await assertSafeRemoteUrl(rawUrl);
+    const maxBytes = Math.min(Math.max(options.maxBytes || DEFAULT_MAX_REMOTE_MEDIA_BYTES, 1), MAX_REMOTE_MEDIA_BYTES);
+    const fetchImpl = options.fetch || globalThis.fetch;
+    const response = await fetchImpl(url, {
+        method: "GET",
+        redirect: "follow",
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch remote media: HTTP ${response.status}`);
+    }
+    const contentLength = response.headers.get("content-length");
+    if (contentLength && Number(contentLength) > maxBytes) {
+        throw new Error(`Remote media exceeds the ${maxBytes} byte limit.`);
+    }
+    const mimeType = options.mimeType || response.headers.get("content-type")?.split(";")[0]?.trim() || "";
+    assertSupportedMimeType(mimeType);
+    const bytes = await readLimitedBytes(response, maxBytes);
+    return {
+        bytes,
+        filename: options.filename || filenameFromUrl(url),
+        mimeType,
+        size: bytes.byteLength,
+    };
+}

package/dist/tools.d.ts

@@ -0,0 +1,12 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BlitzPlanner, BlitzPlannerOptions } from "@blitz-planner/sdk";
+export type BlitzSdkFactory = (options: BlitzPlannerOptions) => BlitzPlanner;
+export interface CreateBlitzMcpServerOptions {
+    apiKey: string;
+    baseUrl?: string;
+    sdkFactory?: BlitzSdkFactory;
+    fetch?: typeof fetch;
+}
+export declare const BLITZ_MCP_TOOL_NAMES: readonly ["blitz_list_platforms", "blitz_list_projects", "blitz_list_accounts", "blitz_create_connection_links", "blitz_get_capabilities", "blitz_upload_media_from_urls", "blitz_create_post", "blitz_schedule_post", "blitz_publish_post_now", "blitz_publish_existing_post", "blitz_get_calendar", "blitz_get_history"];
+export declare function createBlitzMcpServer(options: CreateBlitzMcpServerOptions): McpServer;
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAqC,MAAM,oBAAoB,CAAC;AAI1G,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,EAAE,mBAAmB,KAAK,YAAY,CAAC;AAE7E,MAAM,WAAW,2BAA2B;IAC1C,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CACtB;AAED,eAAO,MAAM,oBAAoB,4TAavB,CAAC;AAwFX,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,2BAA2B,GAAG,SAAS,CA8MpF"}

package/dist/tools.js

@@ -0,0 +1,237 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BlitzPlanner } from "@blitz-planner/sdk";
+import { z } from "zod/v4";
+import { downloadRemoteMedia } from "./media-url.js";
+export const BLITZ_MCP_TOOL_NAMES = [
+    "blitz_list_platforms",
+    "blitz_list_projects",
+    "blitz_list_accounts",
+    "blitz_create_connection_links",
+    "blitz_get_capabilities",
+    "blitz_upload_media_from_urls",
+    "blitz_create_post",
+    "blitz_schedule_post",
+    "blitz_publish_post_now",
+    "blitz_publish_existing_post",
+    "blitz_get_calendar",
+    "blitz_get_history",
+];
+const socialPlatform = z.enum([
+    "LINKEDIN",
+    "FACEBOOK",
+    "INSTAGRAM",
+    "TIKTOK",
+    "TWITTER",
+    "YOUTUBE",
+    "THREADS",
+    "PINTEREST",
+]);
+const mediaType = z.enum([
+    "IMAGE",
+    "VIDEO",
+    "CAROUSEL",
+    "STORY",
+    "REEL",
+    "ARTICLE",
+    "DOCUMENT",
+    "LIVE",
+]);
+const postStatus = z.enum([
+    "DRAFT",
+    "PENDING_APPROVAL",
+    "APPROVED",
+    "SCHEDULED",
+    "PUBLISHING",
+    "PUBLISHED",
+    "FAILED",
+    "DELETED",
+    "PARTIALLY_PUBLISHED",
+]);
+const tiktokSettingsSchema = z
+    .object({
+    privacyLevel: z.string().optional(),
+    disableComment: z.boolean().optional(),
+    disableDuet: z.boolean().optional(),
+    disableStitch: z.boolean().optional(),
+    autoAddMusic: z.boolean().optional(),
+    photoCoverIndex: z.number().int().min(0).optional(),
+    postMode: z.string().optional(),
+})
+    .optional();
+const createPostShape = {
+    projectId: z.string().optional(),
+    content: z.string().min(1),
+    title: z.string().optional(),
+    hashtags: z.array(z.string()).optional(),
+    mentions: z.array(z.string()).optional(),
+    tags: z.array(z.string()).optional(),
+    mediaUrls: z.array(z.url()).optional(),
+    mediaIds: z.array(z.string()).optional(),
+    mediaType: mediaType.optional(),
+    thumbnailUrl: z.url().optional(),
+    scheduledAt: z.string().datetime().optional(),
+    scheduledTimezone: z.string().optional(),
+    accountIds: z.array(z.string()).optional(),
+    platform: socialPlatform.optional(),
+    publishNow: z.boolean().optional(),
+    externalId: z.string().optional(),
+    sourceRef: z.string().optional(),
+    tiktok: tiktokSettingsSchema,
+    accountOverrides: z.record(z.string(), z.object({
+        content: z.string().optional(),
+        hashtags: z.array(z.string()).optional(),
+        platformSettings: z.record(z.string(), z.unknown()).optional(),
+    })).optional(),
+};
+function jsonContent(data) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(data, null, 2),
+            },
+        ],
+    };
+}
+export function createBlitzMcpServer(options) {
+    const sdkFactory = options.sdkFactory || ((clientOptions) => new BlitzPlanner(clientOptions));
+    const sdk = sdkFactory({
+        apiKey: options.apiKey,
+        baseUrl: options.baseUrl,
+        fetch: options.fetch,
+    });
+    const server = new McpServer({
+        name: "blitz-planner",
+        version: "0.1.0",
+    });
+    server.registerTool("blitz_list_platforms", {
+        title: "List Blitz Planner platforms",
+        description: "List the social platforms configured in Blitz Planner.",
+        inputSchema: {},
+    }, async () => jsonContent(await sdk.platforms()));
+    server.registerTool("blitz_list_projects", {
+        title: "List Blitz Planner projects",
+        description: "List projects available to the Blitz API key.",
+        inputSchema: {
+            organizationId: z.string().optional(),
+        },
+    }, async ({ organizationId }) => jsonContent(await sdk.projects.list({ organizationId })));
+    server.registerTool("blitz_list_accounts", {
+        title: "List Blitz Planner social accounts",
+        description: "List connected social accounts available to the Blitz API key.",
+        inputSchema: {
+            organizationId: z.string().optional(),
+            projectId: z.string().optional(),
+            platform: socialPlatform.optional(),
+            status: z.enum(["ACTIVE", "EXPIRED", "ERROR", "REVOKED"]).optional(),
+        },
+    }, async (input) => jsonContent(await sdk.accounts.list(input)));
+    server.registerTool("blitz_create_connection_links", {
+        title: "Create Blitz Planner connection links",
+        description: "Create one or many OAuth URLs for users to connect social accounts.",
+        inputSchema: {
+            platforms: z.array(socialPlatform).min(1),
+            organizationId: z.string().optional(),
+            projectId: z.string().optional(),
+            returnUrl: z.url().optional(),
+        },
+    }, async (input) => jsonContent(await sdk.connections.createLinks(input)));
+    server.registerTool("blitz_get_capabilities", {
+        title: "Get Blitz Planner publishing capabilities",
+        description: "Read account-specific publishing capabilities for a project and optional media IDs.",
+        inputSchema: {
+            projectId: z.string().optional(),
+            mediaIds: z.array(z.string()).optional(),
+        },
+    }, async (input) => jsonContent(await sdk.capabilities.get(input)));
+    server.registerTool("blitz_upload_media_from_urls", {
+        title: "Upload remote media URLs to Blitz Planner",
+        description: "Fetch public image/video URLs safely, upload them to Blitz Planner, and return media IDs.",
+        inputSchema: {
+            projectId: z.string().optional(),
+            maxBytes: z.number().int().min(1).optional(),
+            media: z.array(z.object({
+                url: z.url(),
+                filename: z.string().optional(),
+                mimeType: z.string().optional(),
+                altText: z.string().optional(),
+                width: z.number().int().min(1).optional(),
+                height: z.number().int().min(1).optional(),
+                duration: z.number().min(0).optional(),
+            })).min(1),
+        },
+    }, async ({ projectId, media, maxBytes }) => {
+        const uploads = [];
+        for (const item of media) {
+            const downloaded = await downloadRemoteMedia(item.url, {
+                fetch: options.fetch,
+                maxBytes,
+                filename: item.filename,
+                mimeType: item.mimeType,
+            });
+            uploads.push({
+                projectId,
+                filename: downloaded.filename,
+                mimeType: downloaded.mimeType,
+                size: downloaded.size,
+                body: downloaded.bytes,
+                altText: item.altText,
+                width: item.width,
+                height: item.height,
+                duration: item.duration,
+            });
+        }
+        return jsonContent(await sdk.media.uploadMany(uploads));
+    });
+    server.registerTool("blitz_create_post", {
+        title: "Create a Blitz Planner post",
+        description: "Create a draft or API-created post. Use scheduledAt for planning or publishNow for instant posting.",
+        inputSchema: createPostShape,
+    }, async (input) => jsonContent(await sdk.posts.create(input)));
+    server.registerTool("blitz_schedule_post", {
+        title: "Schedule a Blitz Planner post",
+        description: "Create a Blitz Planner post scheduled for a future ISO timestamp.",
+        inputSchema: {
+            ...createPostShape,
+            scheduledAt: z.string().datetime(),
+        },
+    }, async (input) => jsonContent(await sdk.schedulePost(input)));
+    server.registerTool("blitz_publish_post_now", {
+        title: "Publish a new Blitz Planner post now",
+        description: "Create a Blitz Planner post and immediately request publishing.",
+        inputSchema: createPostShape,
+    }, async (input) => jsonContent(await sdk.publishNow(input)));
+    server.registerTool("blitz_publish_existing_post", {
+        title: "Publish an existing Blitz Planner post",
+        description: "Request publishing for an existing Blitz Planner post ID.",
+        inputSchema: {
+            postId: z.string(),
+        },
+    }, async ({ postId }) => jsonContent(await sdk.posts.publish(postId)));
+    server.registerTool("blitz_get_calendar", {
+        title: "Get Blitz Planner calendar",
+        description: "Read scheduled posts from a project or organization calendar.",
+        inputSchema: {
+            organizationId: z.string().optional(),
+            projectId: z.string().optional(),
+            platform: socialPlatform.optional(),
+            startDate: z.string().datetime().optional(),
+            endDate: z.string().datetime().optional(),
+        },
+    }, async (input) => jsonContent(await sdk.calendar.list(input)));
+    server.registerTool("blitz_get_history", {
+        title: "Get Blitz Planner publishing history",
+        description: "Read publishing history from Blitz Planner.",
+        inputSchema: {
+            organizationId: z.string().optional(),
+            projectId: z.string().optional(),
+            platform: socialPlatform.optional(),
+            accountId: z.string().optional(),
+            startDate: z.string().datetime().optional(),
+            endDate: z.string().datetime().optional(),
+            limit: z.number().int().min(1).optional(),
+            offset: z.number().int().min(0).optional(),
+        },
+    }, async (input) => jsonContent(await sdk.history.list(input)));
+    return server;
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@blitz-planner/mcp-server",
+  "version": "0.1.0",
+  "description": "Remote Streamable HTTP MCP server for Blitz Planner.",
+  "type": "module",
+  "private": false,
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "blitz-planner-mcp": "./dist/index.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^3.25.76",
+    "@blitz-planner/sdk": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.7.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js",
+    "test": "tsx --test src/*.test.ts"
+  }
+}