@publishq/mcp 0.0.5 → 0.0.7

package/README.md

@@ -14,11 +14,33 @@
 
 This is the official [MCP](https://modelcontextprotocol.io) server for [PublishQ](https://publishq.com). Point Claude Desktop, Cursor, or any MCP-compatible agent at it and they can list your connected accounts, create and schedule posts, manage workspaces, and upload media, all through the [PublishQ API](https://publishq.com/docs).
 
-It runs locally over stdio and talks to the PublishQ API using your API key.
+There are two ways to use it:
 
-## Setup
+- **Hosted:** connect to `https://publishq.com/mcp`. You sign in to PublishQ in your browser and approve the app. Nothing to install and no key to copy.
+- **Local:** run this package over stdio with `npx`.
 
-You need a PublishQ API key. Create one under **API Keys** in the PublishQ dashboard (it starts with `pq_live_`).
+## Hosted server
+
+Add `https://publishq.com/mcp` as a remote MCP server in your client. On first use it opens PublishQ in your browser, you sign in and choose what the app may do, and the client stores the login and refreshes it on its own.
+
+- **Claude (claude.ai, Desktop, mobile):** Settings, Connectors, Add custom connector, then paste the URL.
+- **ChatGPT:** turn on developer mode under Settings, then create an app with the URL and OAuth as the authentication.
+- **Claude Code:** `claude mcp add --transport http publishq https://publishq.com/mcp`
+- **Cursor, VS Code, Kiro and other clients:** add a server of type `http` with the URL.
+
+Clients that cannot sign in through a browser can send an API key instead, as an `Authorization: Bearer pq_live_...` header.
+
+You can see and disconnect every connected app under **API Keys** in the PublishQ dashboard.
+
+## Local server
+
+Sign in once with the CLI, and the local server uses that login:
+
+```bash
+npx @publishq/cli@latest login
+```
+
+Or create an API key under **API Keys** in the PublishQ dashboard (it starts with `pq_live_`) and pass it as `PUBLISHQ_API_KEY`.
 
 ### Claude Desktop
 
@@ -29,10 +51,7 @@ Add this to your `claude_desktop_config.json`:
   "mcpServers": {
     "publishq": {
       "command": "npx",
-      "args": ["-y", "@publishq/mcp@latest"],
-      "env": {
-        "PUBLISHQ_API_KEY": "pq_live_your_key_here"
-      }
+      "args": ["-y", "@publishq/mcp@latest"]
     }
   }
 }
@@ -42,13 +61,13 @@ Restart Claude Desktop and you'll see the PublishQ tools available. Now you can
 
 ### Other clients (Cursor, Windsurf, etc.)
 
-Any MCP client that launches a stdio server works the same way: run the command `npx -y @publishq/mcp@latest` with `PUBLISHQ_API_KEY` set in the environment.
+Any MCP client that launches a stdio server works the same way: run the command `npx -y @publishq/mcp@latest`, after `publishq login` or with `PUBLISHQ_API_KEY` set in the environment.
 
 ## Configuration
 
 | Variable           | Required | Description                                                        |
 | ------------------ | -------- | ------------------------------------------------------------------ |
-| `PUBLISHQ_API_KEY` | Yes      | Your PublishQ API key (`pq_live_...`).                             |
+| `PUBLISHQ_API_KEY` | No       | Your PublishQ API key (`pq_live_...`). Not needed after `publishq login`. |
 | `PUBLISHQ_API_URL` | No       | Override the API base URL (defaults to `https://publishq.com/api/v1`). |
 
 ## Tools
@@ -68,14 +87,15 @@ Any MCP client that launches a stdio server works the same way: run the command
 | `publishq_create_workspace`         | Create a workspace                                      |
 | `publishq_list_media`               | List uploaded/generated media                           |
 | `publishq_get_media`                | Get one media file by ID                                |
-| `publishq_upload_media`             | Upload a local file (up to 4 GB) and get a media ID     |
+| `publishq_upload_media`             | Upload a file and get a media ID: a local path (local server) or a link or chat attachment (hosted server) |
+| `publishq_create_media_upload`      | Get a signed URL to upload a file from your own disk, up to 4 GB |
 | `publishq_delete_media`             | Delete a media file no draft or scheduled post uses     |
 
 The tools are thin wrappers over [`@publishq/sdk`](https://www.npmjs.com/package/@publishq/sdk), so their behavior and scopes match the [PublishQ API](https://publishq.com/docs). `publishq_create_post` accepts an `accounts` array whose entries contain `accountId` plus optional `postOverrides` and `platformSpecificSettings`. `publishq_update_post` accepts content, scheduling, complete media replacement or removal, and thumbnail timestamp changes. `publishq_list_media` can filter by media IDs, types, and sources. For TikTok, the agent should call `publishq_get_tiktok_creator_info` first and then provide the required privacy and interaction settings in that account object. A tool call that hits an API error returns the API error so the agent can react.
 
 ## Scopes
 
-Tools require the same API-key scopes as the underlying endpoints: `posts:read`/`posts:write`, `accounts:read`, `workspaces:read`/`workspaces:write`, and `media:read`/`media:write`. Grant a key only the scopes your agent needs.
+Tools require the same scopes as the underlying endpoints: `posts:read`/`posts:write`, `accounts:read`, `workspaces:read`/`workspaces:write`, and `media:read`/`media:write`. Grant a key or an app only the scopes your agent needs.
 
 ## Related
 

package/dist/index.js

@@ -3,15 +3,20 @@
 // src/index.ts
 import { openAsBlob, statSync } from "fs";
 import { basename } from "path";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import PublishQ from "@publishq/sdk";
+import { resolveCredential } from "@publishq/sdk/credentials";
+
+// src/tools.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import {
   CallToolRequestSchema,
   ErrorCode,
   ListToolsRequestSchema,
   McpError
 } from "@modelcontextprotocol/sdk/types.js";
-import PublishQ, {
+import {
+  zCreateMediaUploadBody,
   zCreatePostBody,
   zCreateWorkspaceBody,
   zDeleteMediaPath,
@@ -28,18 +33,6 @@ import PublishQ, {
   zUpdatePostPath
 } from "@publishq/sdk";
 import { toJSONSchema } from "zod/v4-mini";
-var OPEN_AS_BLOB_MAX_BYTES = 2 ** 32;
-var API_KEY = process.env.PUBLISHQ_API_KEY;
-if (!API_KEY) {
-  console.error(
-    "ERROR: PUBLISHQ_API_KEY environment variable is required. Create a key at https://publishq.com/app/api-keys."
-  );
-  process.exit(1);
-}
-var publishq = new PublishQ({
-  apiKey: API_KEY,
-  ...process.env.PUBLISHQ_API_URL ? { baseUrl: process.env.PUBLISHQ_API_URL } : {}
-});
 function describeError(error) {
   const cause = error.cause;
   if (cause instanceof Error) {
@@ -74,8 +67,38 @@ async function run(call) {
     return errorResult(error);
   }
 }
+var isPlainObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var isAnnotationOnly = (node) => isPlainObject(node) && Object.keys(node).every((key) => key === "description" || key === "title");
+var isEmpty = (value) => isPlainObject(value) && Object.keys(value).length === 0;
+function booleanSchema(value) {
+  if (isEmpty(value)) return true;
+  if (isPlainObject(value) && Object.keys(value).length === 1 && isEmpty(value.not)) {
+    return false;
+  }
+  return void 0;
+}
+function portableSchema(node) {
+  if (Array.isArray(node)) return node.map(portableSchema);
+  if (!isPlainObject(node)) return node;
+  const result = {};
+  for (const [key, value] of Object.entries(node)) {
+    result[key] = key === "additionalProperties" ? booleanSchema(value) ?? portableSchema(value) : portableSchema(value);
+  }
+  const allOf = result.allOf;
+  if (Array.isArray(allOf)) {
+    const annotations = allOf.filter(isAnnotationOnly);
+    const schemas = allOf.filter((member) => !isAnnotationOnly(member));
+    if (annotations.length > 0 && schemas.length === 1 && isPlainObject(schemas[0])) {
+      delete result.allOf;
+      return { ...Object.assign({}, ...annotations), ...schemas[0], ...result };
+    }
+  }
+  return result;
+}
 function advertisedSchema(schema) {
-  const jsonSchema = toJSONSchema(schema, { io: "input", target: "draft-7" });
+  const jsonSchema = portableSchema(
+    toJSONSchema(schema, { io: "input", target: "draft-7" })
+  );
   if (jsonSchema.type !== "object") {
     throw new Error("MCP tool input schema must describe an object.");
   }
@@ -96,224 +119,258 @@ function mergedAdvertisedSchema(...schemas) {
     additionalProperties: false
   };
 }
-var tools = /* @__PURE__ */ new Map();
-function registerTool(definition, handler) {
-  tools.set(definition.name, { definition, handler });
-}
-registerTool(
-  {
-    name: "publishq_list_posts",
-    title: "List posts",
-    description: "List the posts on the authenticated PublishQ account. Paginated. Each post includes its connected accounts and status (DRAFT, SCHEDULED, PUBLISHING, PUBLISHED, FAILED).",
-    inputSchema: advertisedSchema(zListPostsQuery),
-    annotations: { readOnlyHint: true, openWorldHint: true }
-  },
-  (args) => run(publishq.posts.list(args))
-);
-registerTool(
-  {
-    name: "publishq_get_post",
-    title: "Get a post",
-    description: "Get one post by its PublishQ post ID.",
-    inputSchema: advertisedSchema(zGetPostPath),
-    annotations: { readOnlyHint: true, openWorldHint: true }
-  },
-  (args) => run(publishq.posts.get(args.id))
-);
-registerTool(
-  {
-    name: "publishq_create_post",
-    title: "Create a post",
-    description: "Create a post for one or more connected accounts. Get account IDs from publishq_list_accounts. Each account accepts postOverrides and platformSpecificSettings. Before posting to TikTok, call publishq_get_tiktok_creator_info and include all required TikTok settings. Omit both scheduledAt and publishNow to save as a draft; set publishNow to publish immediately, or scheduledAt (ISO 8601) to schedule for later.",
-    inputSchema: advertisedSchema(zCreatePostBody),
-    annotations: { readOnlyHint: false, openWorldHint: true }
-  },
-  (args) => run(publishq.posts.create(args))
-);
-registerTool(
-  {
-    name: "publishq_update_post",
-    title: "Update a post",
-    description: "Update a draft or scheduled post. Supports content, scheduledAt, complete media replacement/removal through mediaIds, thumbnailTimestamp, and accounts (each with postOverrides and platformSpecificSettings, for example a YouTube thumbnailMediaId). Only the fields you send change; send a field as null to remove it. Published and publishing posts cannot be updated.",
-    inputSchema: mergedAdvertisedSchema(zUpdatePostPath, zUpdatePostBody),
-    annotations: { readOnlyHint: false, idempotentHint: true, openWorldHint: true }
-  },
-  (args) => {
-    const { id, ...body } = args;
-    return run(
-      publishq.posts.update(id, body)
-    );
-  }
-);
-registerTool(
-  {
-    name: "publishq_delete_post",
-    title: "Delete a post",
-    description: "Delete a scheduled or draft post by its ID. This cannot be undone.",
-    inputSchema: advertisedSchema(zDeletePostPath),
-    annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true }
-  },
-  (args) => run(publishq.posts.delete(args.id))
-);
-registerTool(
-  {
-    name: "publishq_remove_post_account",
-    title: "Remove an account from a post",
-    description: "Remove one account from an existing post so it will no longer be published there. Other accounts in the same post are unaffected.",
-    inputSchema: advertisedSchema(zRemovePostAccountPath),
-    annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true }
-  },
-  (args) => run(
-    publishq.posts.removeAccount(
-      args.id,
-      args.accountId
+function publishqTools(publishq2) {
+  const tools = [];
+  const register = (definition, handler) => {
+    tools.push({ definition, handler });
+  };
+  register(
+    {
+      name: "publishq_list_posts",
+      title: "List posts",
+      description: "List the posts on the authenticated PublishQ account. Paginated. Each post includes its connected accounts and status (DRAFT, SCHEDULED, PUBLISHING, PUBLISHED, FAILED).",
+      inputSchema: advertisedSchema(zListPostsQuery),
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    (args) => run(publishq2.posts.list(args))
+  );
+  register(
+    {
+      name: "publishq_get_post",
+      title: "Get a post",
+      description: "Get one post by its PublishQ post ID.",
+      inputSchema: advertisedSchema(zGetPostPath),
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    (args) => run(publishq2.posts.get(args.id))
+  );
+  register(
+    {
+      name: "publishq_create_post",
+      title: "Create a post",
+      description: "Create a post for one or more connected accounts. Get account IDs from publishq_list_accounts. Each account accepts postOverrides and platformSpecificSettings. Before posting to TikTok, call publishq_get_tiktok_creator_info and include all required TikTok settings. Omit both scheduledAt and publishNow to save as a draft; set publishNow to publish immediately, or scheduledAt (ISO 8601) to schedule for later.",
+      inputSchema: advertisedSchema(zCreatePostBody),
+      annotations: { readOnlyHint: false, openWorldHint: true }
+    },
+    (args) => run(publishq2.posts.create(args))
+  );
+  register(
+    {
+      name: "publishq_update_post",
+      title: "Update a post",
+      description: "Update a draft or scheduled post. Supports content, scheduledAt, complete media replacement/removal through mediaIds, thumbnailTimestamp, and accounts (each with postOverrides and platformSpecificSettings, for example a YouTube thumbnailMediaId). Only the fields you send change; send a field as null to remove it. Published and publishing posts cannot be updated.",
+      inputSchema: mergedAdvertisedSchema(zUpdatePostPath, zUpdatePostBody),
+      annotations: { readOnlyHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    (args) => {
+      const { id, ...body } = args;
+      return run(
+        publishq2.posts.update(id, body)
+      );
+    }
+  );
+  register(
+    {
+      name: "publishq_delete_post",
+      title: "Delete a post",
+      description: "Delete a scheduled or draft post by its ID. This cannot be undone.",
+      inputSchema: advertisedSchema(zDeletePostPath),
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true }
+    },
+    (args) => run(publishq2.posts.delete(args.id))
+  );
+  register(
+    {
+      name: "publishq_remove_post_account",
+      title: "Remove an account from a post",
+      description: "Remove one account from an existing post so it will no longer be published there. Other accounts in the same post are unaffected.",
+      inputSchema: advertisedSchema(zRemovePostAccountPath),
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true }
+    },
+    (args) => run(
+      publishq2.posts.removeAccount(
+        args.id,
+        args.accountId
+      )
     )
-  )
-);
-registerTool(
-  {
-    name: "publishq_list_accounts",
-    title: "List connected accounts",
-    description: "List the social accounts connected to the authenticated PublishQ account. Optionally filter by workspace and platform. Use the returned account IDs when creating posts.",
-    inputSchema: advertisedSchema(zListAccountsQuery),
-    annotations: { readOnlyHint: true, openWorldHint: true }
-  },
-  (args) => run(publishq.accounts.list(args))
-);
-registerTool(
-  {
-    name: "publishq_get_tiktok_creator_info",
-    title: "Get TikTok creator info",
-    description: "Get a TikTok account's current privacy options, interaction settings, and max video duration. Call this before creating a TikTok post. The privacyLevel you set must be one of the returned privacyLevelOptions.",
-    inputSchema: advertisedSchema(zGetTikTokCreatorInfoPath),
-    annotations: { readOnlyHint: true, openWorldHint: true }
-  },
-  (args) => run(publishq.accounts.getTikTokCreatorInfo(args.id))
-);
-registerTool(
-  {
-    name: "publishq_list_workspaces",
-    title: "List workspaces",
-    description: "List your workspaces, including their names, colors, and account counts.",
-    inputSchema: { type: "object", properties: {} },
-    annotations: { readOnlyHint: true, openWorldHint: true }
-  },
-  () => run(publishq.workspaces.list())
-);
-registerTool(
-  {
-    name: "publishq_get_workspace",
-    title: "Get a workspace",
-    description: "Get one workspace by its ID.",
-    inputSchema: advertisedSchema(zGetWorkspacePath),
-    annotations: { readOnlyHint: true, openWorldHint: true }
-  },
-  (args) => run(publishq.workspaces.get(args.id))
-);
-registerTool(
-  {
-    name: "publishq_create_workspace",
-    title: "Create a workspace",
-    description: "Create a workspace to organize your connected accounts.",
-    inputSchema: advertisedSchema(zCreateWorkspaceBody),
-    annotations: { readOnlyHint: false, openWorldHint: true }
-  },
-  (args) => run(publishq.workspaces.create(args))
-);
-registerTool(
-  {
-    name: "publishq_list_media",
-    title: "List media",
-    description: "List your uploaded and generated media files. Optionally filter by media ID, type, and source.",
-    inputSchema: advertisedSchema(zListMediaQuery),
-    annotations: { readOnlyHint: true, openWorldHint: true }
-  },
-  (args) => run(publishq.media.list(args))
-);
-registerTool(
-  {
-    name: "publishq_get_media",
-    title: "Get a media file",
-    description: "Get one media file by its ID, including its URL and usage.",
-    inputSchema: advertisedSchema(zGetMediaPath),
-    annotations: { readOnlyHint: true, openWorldHint: true }
-  },
-  (args) => run(publishq.media.get(args.id))
-);
-registerTool(
-  {
-    name: "publishq_delete_media",
-    title: "Delete a media file",
-    description: "Delete a media file by its ID, from the media library and from storage. Refused while a draft or scheduled post uses it: publish or delete that post first. This cannot be undone.",
-    inputSchema: advertisedSchema(zDeleteMediaPath),
-    annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true }
-  },
-  (args) => run(publishq.media.delete(args.id))
-);
-registerTool(
+  );
+  register(
+    {
+      name: "publishq_list_accounts",
+      title: "List connected accounts",
+      description: "List the social accounts connected to the authenticated PublishQ account. Optionally filter by workspace and platform. Use the returned account IDs when creating posts.",
+      inputSchema: advertisedSchema(zListAccountsQuery),
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    (args) => run(publishq2.accounts.list(args))
+  );
+  register(
+    {
+      name: "publishq_get_tiktok_creator_info",
+      title: "Get TikTok creator info",
+      description: "Get a TikTok account's current privacy options, interaction settings, and max video duration. Call this before creating a TikTok post. The privacyLevel you set must be one of the returned privacyLevelOptions.",
+      inputSchema: advertisedSchema(zGetTikTokCreatorInfoPath),
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    (args) => run(publishq2.accounts.getTikTokCreatorInfo(args.id))
+  );
+  register(
+    {
+      name: "publishq_list_workspaces",
+      title: "List workspaces",
+      description: "List your workspaces, including their names, colors, and account counts.",
+      inputSchema: { type: "object", properties: {} },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    () => run(publishq2.workspaces.list())
+  );
+  register(
+    {
+      name: "publishq_get_workspace",
+      title: "Get a workspace",
+      description: "Get one workspace by its ID.",
+      inputSchema: advertisedSchema(zGetWorkspacePath),
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    (args) => run(publishq2.workspaces.get(args.id))
+  );
+  register(
+    {
+      name: "publishq_create_workspace",
+      title: "Create a workspace",
+      description: "Create a workspace to organize your connected accounts.",
+      inputSchema: advertisedSchema(zCreateWorkspaceBody),
+      annotations: { readOnlyHint: false, openWorldHint: true }
+    },
+    (args) => run(publishq2.workspaces.create(args))
+  );
+  register(
+    {
+      name: "publishq_list_media",
+      title: "List media",
+      description: "List your uploaded and generated media files. Optionally filter by media ID, type, and source.",
+      inputSchema: advertisedSchema(zListMediaQuery),
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    (args) => run(publishq2.media.list(args))
+  );
+  register(
+    {
+      name: "publishq_get_media",
+      title: "Get a media file",
+      description: "Get one media file by its ID, including its URL and usage.",
+      inputSchema: advertisedSchema(zGetMediaPath),
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    (args) => run(publishq2.media.get(args.id))
+  );
+  register(
+    {
+      name: "publishq_create_media_upload",
+      title: "Start a media upload",
+      description: 'Get a signed upload URL for a file of up to 4 GB on the machine you run commands on, and the media ID it becomes. Send the file with a PUT to uploadUrl, with the same Content-Type and no Authorization header, for example `curl -X PUT -H "Content-Type: image/jpeg" --upload-file ./photo.jpg "<uploadUrl>"`. Then attach the media ID to a post through mediaIds. The URL expires after an hour.',
+      inputSchema: advertisedSchema(zCreateMediaUploadBody),
+      annotations: { readOnlyHint: false, openWorldHint: true }
+    },
+    (args) => run(publishq2.media.createUpload(args))
+  );
+  register(
+    {
+      name: "publishq_delete_media",
+      title: "Delete a media file",
+      description: "Delete a media file by its ID, from the media library and from storage. Refused while a draft or scheduled post uses it: publish or delete that post first. This cannot be undone.",
+      inputSchema: advertisedSchema(zDeleteMediaPath),
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true }
+    },
+    (args) => run(publishq2.media.delete(args.id))
+  );
+  return tools;
+}
+function createPublishQServer(tools) {
+  const byName = new Map(tools.map((tool) => [tool.definition.name, tool]));
+  const server2 = new McpServer(
+    { name: "publishq", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+  server2.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: tools.map(({ definition }) => definition)
+  }));
+  server2.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const registered = byName.get(request.params.name);
+    if (!registered) {
+      throw new McpError(
+        ErrorCode.InvalidParams,
+        `Unknown tool: ${request.params.name}`
+      );
+    }
+    try {
+      return await registered.handler(request.params.arguments ?? {});
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  return server2;
+}
+
+// src/index.ts
+var OPEN_AS_BLOB_MAX_BYTES = 2 ** 32;
+var credential = resolveCredential();
+if (!credential) {
+  console.error(
+    "ERROR: not signed in. Run `npx @publishq/cli login`, or set the PUBLISHQ_API_KEY environment variable to a key from https://publishq.com/app/api-keys."
+  );
+  process.exit(1);
+}
+var publishq = new PublishQ({
+  apiKey: credential.apiKey,
+  ...credential.baseUrl ? { baseUrl: credential.baseUrl } : {}
+});
+var server = createPublishQServer([
+  ...publishqTools(publishq),
   {
-    name: "publishq_upload_media",
-    title: "Upload a media file",
-    description: "Upload a local media file of up to 4 GB to PublishQ and get back a media ID you can attach to posts via publishq_create_post (mediaIds). The file is read from the local filesystem where this MCP server runs.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        filePath: {
-          type: "string",
-          description: "Absolute path to the local file to upload"
+    definition: {
+      name: "publishq_upload_media",
+      title: "Upload a media file",
+      description: "Upload a local media file of up to 4 GB to PublishQ and get back a media ID you can attach to posts via publishq_create_post (mediaIds). The file is read from the local filesystem where this MCP server runs.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          filePath: {
+            type: "string",
+            description: "Absolute path to the local file to upload"
+          },
+          filename: {
+            type: "string",
+            description: "Override the uploaded file name"
+          }
         },
-        filename: {
-          type: "string",
-          description: "Override the uploaded file name"
-        }
+        required: ["filePath"],
+        additionalProperties: false
       },
-      required: ["filePath"],
-      additionalProperties: false
+      annotations: { readOnlyHint: false, openWorldHint: true }
     },
-    annotations: { readOnlyHint: false, openWorldHint: true }
-  },
-  async (args) => {
-    const filePath = args.filePath;
-    const filename = args.filename;
-    if (statSync(filePath).size >= OPEN_AS_BLOB_MAX_BYTES) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `${filePath} is too big to upload: files must be smaller than 4 GB.`
-          }
-        ],
-        isError: true
-      };
+    handler: async (args) => {
+      const filePath = args.filePath;
+      const filename = args.filename;
+      if (statSync(filePath).size >= OPEN_AS_BLOB_MAX_BYTES) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `${filePath} is too big to upload: files must be smaller than 4 GB.`
+            }
+          ],
+          isError: true
+        };
+      }
+      const file = new File(
+        [await openAsBlob(filePath)],
+        filename ?? basename(filePath)
+      );
+      return run(publishq.media.upload({ file }));
     }
-    const file = new File(
-      [await openAsBlob(filePath)],
-      filename ?? basename(filePath)
-    );
-    return run(publishq.media.upload({ file }));
-  }
-);
-var server = new McpServer(
-  { name: "publishq", version: "0.1.0" },
-  { capabilities: { tools: {} } }
-);
-server.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [...tools.values()].map(({ definition }) => definition)
-}));
-server.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const registered = tools.get(request.params.name);
-  if (!registered) {
-    throw new McpError(
-      ErrorCode.InvalidParams,
-      `Unknown tool: ${request.params.name}`
-    );
   }
-  try {
-    return await registered.handler(request.params.arguments ?? {});
-  } catch (error) {
-    return errorResult(error);
-  }
-});
+]);
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@publishq/mcp",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "private": false,
   "description": "Model Context Protocol (MCP) server for PublishQ. Let AI agents schedule and publish across your social platforms.",
   "license": "Apache-2.0",
@@ -31,7 +31,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.29.0",
     "zod": "4.4.3",
-    "@publishq/sdk": "^0.0.5"
+    "@publishq/sdk": "^0.0.7"
   },
   "devDependencies": {
     "@types/node": "^20",