posterly-mcp-server 0.2.1 → 0.3.0

package/dist/index.js

@@ -7,9 +7,13 @@ import { createPostTool } from './tools/create-post.js';
 import { findSlotTool } from './tools/find-slot.js';
 import { listPostsTool } from './tools/list-posts.js';
 import { uploadMediaTool } from './tools/upload-media.js';
+import { getPostTool } from './tools/get-post.js';
+import { updatePostTool } from './tools/update-post.js';
+import { deletePostTool } from './tools/delete-post.js';
+import { whoamiTool } from './tools/whoami.js';
 const server = new McpServer({
     name: 'posterly',
-    version: '0.1.0',
+    version: '0.3.0',
 });
 let client;
 try {
@@ -20,9 +24,18 @@ catch (err) {
     process.exit(1);
 }
 // Register tools
-server.tool(listAccountsTool.name, listAccountsTool.description, listAccountsTool.inputSchema.shape, async () => {
+server.tool(whoamiTool.name, whoamiTool.description, whoamiTool.inputSchema.shape, async () => {
     try {
-        const text = await listAccountsTool.execute(client);
+        const text = await whoamiTool.execute(client);
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+    }
+});
+server.tool(listAccountsTool.name, listAccountsTool.description, listAccountsTool.inputSchema.shape, async (input) => {
+    try {
+        const text = await listAccountsTool.execute(client, input);
         return { content: [{ type: 'text', text }] };
     }
     catch (err) {
@@ -65,6 +78,33 @@ server.tool(uploadMediaTool.name, uploadMediaTool.description, uploadMediaTool.i
         return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
     }
 });
+server.tool(getPostTool.name, getPostTool.description, getPostTool.inputSchema.shape, async (input) => {
+    try {
+        const text = await getPostTool.execute(client, input);
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+    }
+});
+server.tool(updatePostTool.name, updatePostTool.description, updatePostTool.inputSchema.shape, async (input) => {
+    try {
+        const text = await updatePostTool.execute(client, input);
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+    }
+});
+server.tool(deletePostTool.name, deletePostTool.description, deletePostTool.inputSchema.shape, async (input) => {
+    try {
+        const text = await deletePostTool.execute(client, input);
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
+    }
+});
 // Start the server
 async function main() {
     const transport = new StdioServerTransport();

package/dist/lib/api-client.d.ts

@@ -4,6 +4,7 @@ export interface Account {
     username: string;
     account_type?: string;
     profile_picture_url?: string;
+    workspace_id?: string | null;
 }
 export interface Post {
     id: number;
@@ -16,22 +17,47 @@ export interface Post {
     post_type?: string;
     platform_post_url?: string;
     published_at?: string;
+    workspace_id?: string | null;
 }
 export interface Slot {
     time: string;
     local_time: string;
 }
+export interface Workspace {
+    id: string;
+    name: string;
+    slug: string;
+    is_personal: boolean;
+    timezone?: string | null;
+    role?: string;
+}
+export interface Whoami {
+    user: {
+        id: string;
+        email: string | null;
+    };
+    api_key: {
+        id: string;
+        scopes: string[];
+    };
+    default_workspace: Workspace;
+    workspaces: Workspace[];
+}
 export declare class PosterlyClient {
     private baseUrl;
     private apiKey;
     constructor(apiKey?: string, baseUrl?: string);
     private request;
-    listAccounts(): Promise<Account[]>;
+    whoami(): Promise<Whoami>;
+    listAccounts(params?: {
+        workspace_id?: string;
+    }): Promise<Account[]>;
     listPosts(params?: {
         status?: string;
         platform?: string;
         limit?: number;
         offset?: number;
+        workspace_id?: string;
     }): Promise<{
         posts: Post[];
         total: number;
@@ -46,13 +72,38 @@ export declare class PosterlyClient {
         media_url?: string;
         media_urls?: string[];
         metadata?: Record<string, unknown>;
+        workspace_id?: string;
+    }): Promise<{
+        post: Post;
+        workspace: {
+            id: string;
+            name: string;
+            is_personal: boolean;
+            resolved_from: 'explicit' | 'account' | 'personal';
+        };
+    }>;
+    getPost(id: number): Promise<{
+        post: Post;
+    }>;
+    updatePost(id: number, data: {
+        caption?: string;
+        scheduled_at?: string;
+        media_url?: string;
+        media_urls?: string[];
+        post_type?: string;
+        metadata?: Record<string, unknown>;
     }): Promise<{
         post: Post;
     }>;
+    deletePost(id: number): Promise<{
+        deleted: boolean;
+        id: number;
+    }>;
     findAvailableSlots(params?: {
         account_ids?: string[];
         timezone?: string;
         count?: number;
+        workspace_id?: string;
     }): Promise<Slot[]>;
     getSignedUploadUrl(filename: string, contentType: string, size: number): Promise<{
         upload_url: string;

package/dist/lib/api-client.js

@@ -30,8 +30,15 @@ export class PosterlyClient {
         }
         return res.json();
     }
-    async listAccounts() {
-        const data = await this.request('GET', '/accounts');
+    async whoami() {
+        return this.request('GET', '/whoami');
+    }
+    async listAccounts(params) {
+        const searchParams = new URLSearchParams();
+        if (params?.workspace_id)
+            searchParams.set('workspace_id', params.workspace_id);
+        const qs = searchParams.toString();
+        const data = await this.request('GET', `/accounts${qs ? `?${qs}` : ''}`);
         return data.accounts;
     }
     async listPosts(params) {
@@ -44,12 +51,23 @@ export class PosterlyClient {
             searchParams.set('limit', String(params.limit));
         if (params?.offset)
             searchParams.set('offset', String(params.offset));
+        if (params?.workspace_id)
+            searchParams.set('workspace_id', params.workspace_id);
         const qs = searchParams.toString();
         return this.request('GET', `/posts${qs ? `?${qs}` : ''}`);
     }
     async createPost(data) {
         return this.request('POST', '/posts', data);
     }
+    async getPost(id) {
+        return this.request('GET', `/posts/${id}`);
+    }
+    async updatePost(id, data) {
+        return this.request('PATCH', `/posts/${id}`, data);
+    }
+    async deletePost(id) {
+        return this.request('DELETE', `/posts/${id}`);
+    }
     async findAvailableSlots(params) {
         const searchParams = new URLSearchParams();
         if (params?.account_ids?.length)
@@ -58,6 +76,8 @@ export class PosterlyClient {
             searchParams.set('timezone', params.timezone);
         if (params?.count)
             searchParams.set('count', String(params.count));
+        if (params?.workspace_id)
+            searchParams.set('workspace_id', params.workspace_id);
         const qs = searchParams.toString();
         const data = await this.request('GET', `/slots/next${qs ? `?${qs}` : ''}`);
         return data.slots;

package/dist/tools/create-post.d.ts

@@ -12,8 +12,10 @@ export declare const createPostTool: {
         media_url: z.ZodOptional<z.ZodString>;
         media_urls: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         post_type: z.ZodOptional<z.ZodString>;
+        workspace_id: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         caption: string;
+        workspace_id?: string | undefined;
         platform?: string | undefined;
         account_id?: string | undefined;
         username?: string | undefined;
@@ -23,6 +25,7 @@ export declare const createPostTool: {
         post_type?: string | undefined;
     }, {
         caption: string;
+        workspace_id?: string | undefined;
         platform?: string | undefined;
         account_id?: string | undefined;
         username?: string | undefined;
@@ -40,5 +43,6 @@ export declare const createPostTool: {
         media_url?: string;
         media_urls?: string[];
         post_type?: string;
+        workspace_id?: string;
     }): Promise<string>;
 };

package/dist/tools/create-post.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export const createPostTool = {
     name: 'create_post',
-    description: 'Schedule or immediately publish a social media post. Provide either account_id OR username+platform to identify the account. If scheduled_at is omitted, the post publishes immediately.',
+    description: 'Schedule or immediately publish a social media post. Provide either account_id OR username+platform to identify the account. If scheduled_at is omitted, the post publishes immediately. IMPORTANT: posts belong to a workspace. If workspace_id is omitted, the server resolves one from the social account, falling back to the caller\'s default (personal) workspace. Call `whoami` first in any new session to confirm which workspace posts will land in, and pass workspace_id explicitly if the user has more than one workspace.',
     inputSchema: z.object({
         account_id: z.string().optional().describe('Social account ID (from list_accounts)'),
         username: z.string().optional().describe('Account username (alternative to account_id)'),
@@ -23,13 +23,29 @@ export const createPostTool = {
             .string()
             .optional()
             .describe('Post type: text, image, video, carousel, reel, story'),
+        workspace_id: z
+            .string()
+            .optional()
+            .describe('Workspace ID to assign the post to (from whoami). If omitted, uses the account\'s workspace or the caller\'s default workspace.'),
     }),
     async execute(client, input) {
         const result = await client.createPost(input);
         const p = result.post;
+        const ws = result.workspace;
         const when = p.scheduled_at
             ? new Date(p.scheduled_at).toLocaleString()
             : 'now';
-        return `Post created successfully!\n• ID: ${p.id}\n• Platform: ${p.platform || input.platform || 'unknown'}\n• Type: ${p.post_type}\n• Status: ${p.status}\n• Scheduled: ${when}`;
+        const lines = [
+            'Post created successfully!',
+            `• ID: ${p.id}`,
+            `• Platform: ${p.platform || input.platform || 'unknown'}`,
+            `• Type: ${p.post_type}`,
+            `• Status: ${p.status}`,
+            `• Scheduled: ${when}`,
+        ];
+        if (ws) {
+            lines.push(`• Workspace: ${ws.name} (${ws.id}) — resolved from ${ws.resolved_from}`);
+        }
+        return lines.join('\n');
     },
 };

package/dist/tools/delete-post.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const deletePostTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        post_id: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        post_id: number;
+    }, {
+        post_id: number;
+    }>;
+    execute(client: PosterlyClient, input: {
+        post_id: number;
+    }): Promise<string>;
+};

package/dist/tools/delete-post.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export const deletePostTool = {
+    name: 'delete_post',
+    description: 'Delete a scheduled or draft post. Cannot delete published or currently publishing posts.',
+    inputSchema: z.object({
+        post_id: z.number().describe('The post ID to delete'),
+    }),
+    async execute(client, input) {
+        const result = await client.deletePost(input.post_id);
+        return `Post #${result.id} deleted successfully.`;
+    },
+};

package/dist/tools/find-slot.d.ts

@@ -7,11 +7,14 @@ export declare const findSlotTool: {
         account_ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         timezone: z.ZodOptional<z.ZodString>;
         count: z.ZodOptional<z.ZodNumber>;
+        workspace_id: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
+        workspace_id?: string | undefined;
         account_ids?: string[] | undefined;
         timezone?: string | undefined;
         count?: number | undefined;
     }, {
+        workspace_id?: string | undefined;
         account_ids?: string[] | undefined;
         timezone?: string | undefined;
         count?: number | undefined;
@@ -20,5 +23,6 @@ export declare const findSlotTool: {
         account_ids?: string[];
         timezone?: string;
         count?: number;
+        workspace_id?: string;
     }): Promise<string>;
 };

package/dist/tools/find-slot.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export const findSlotTool = {
     name: 'find_available_slot',
-    description: 'Find available time slots for posting. Respects a 1-hour gap between posts and preferred hours (8am–10pm). Returns up to 10 slots.',
+    description: 'Find available time slots for posting. Respects a 1-hour gap between posts and preferred hours (8am–10pm in the given timezone). Returns up to 10 slots. IMPORTANT: pass a timezone explicitly — default is America/New_York and slots will be off if the user is elsewhere. Pass workspace_id to only avoid collisions with posts in that workspace.',
     inputSchema: z.object({
         account_ids: z
             .array(z.string())
@@ -10,13 +10,17 @@ export const findSlotTool = {
         timezone: z
             .string()
             .optional()
-            .describe('IANA timezone (e.g. America/New_York). Defaults to America/New_York.'),
+            .describe('IANA timezone (e.g. Asia/Dubai, Europe/London). Defaults to America/New_York — pass the user\'s actual timezone or slots will be wrong.'),
         count: z
             .number()
             .min(1)
             .max(10)
             .optional()
             .describe('Number of slots to return (default 5, max 10)'),
+        workspace_id: z
+            .string()
+            .optional()
+            .describe('Scope slot-finding to a single workspace (get IDs via whoami).'),
     }),
     async execute(client, input) {
         const slots = await client.findAvailableSlots(input);

package/dist/tools/get-post.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const getPostTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        post_id: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        post_id: number;
+    }, {
+        post_id: number;
+    }>;
+    execute(client: PosterlyClient, input: {
+        post_id: number;
+    }): Promise<string>;
+};

package/dist/tools/get-post.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export const getPostTool = {
+    name: 'get_post',
+    description: 'Get details of a specific post by ID. Returns caption, status, scheduled time, media, and platform info.',
+    inputSchema: z.object({
+        post_id: z.number().describe('The post ID to look up'),
+    }),
+    async execute(client, input) {
+        const result = await client.getPost(input.post_id);
+        const p = result.post;
+        const lines = [
+            `Post #${p.id}`,
+            `• Status: ${p.status}`,
+            `• Caption: ${p.content || '(empty)'}`,
+            `• Type: ${p.post_type || 'unknown'}`,
+            `• Scheduled: ${p.scheduled_at ? new Date(p.scheduled_at).toLocaleString() : 'N/A'}`,
+        ];
+        if (p.platform_post_url)
+            lines.push(`• Published URL: ${p.platform_post_url}`);
+        if (p.media_url)
+            lines.push(`• Media: ${p.media_url}`);
+        if (p.media_urls?.length)
+            lines.push(`• Media (${p.media_urls.length}): ${p.media_urls.join(', ')}`);
+        return lines.join('\n');
+    },
+};

package/dist/tools/list-accounts.d.ts

@@ -3,6 +3,14 @@ import type { PosterlyClient } from '../lib/api-client.js';
 export declare const listAccountsTool: {
     name: string;
     description: string;
-    inputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-    execute(client: PosterlyClient): Promise<string>;
+    inputSchema: z.ZodObject<{
+        workspace_id: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        workspace_id?: string | undefined;
+    }, {
+        workspace_id?: string | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        workspace_id?: string;
+    }): Promise<string>;
 };

package/dist/tools/list-accounts.js

@@ -1,14 +1,21 @@
 import { z } from 'zod';
 export const listAccountsTool = {
     name: 'list_accounts',
-    description: 'List all connected social media accounts. Shows platform, username, and account ID for each.',
-    inputSchema: z.object({}),
-    async execute(client) {
-        const accounts = await client.listAccounts();
+    description: 'List connected social media accounts. Returns platform, username, account ID, and workspace ID for each. Pass workspace_id to filter to a specific workspace; otherwise returns all accounts the caller owns across every workspace.',
+    inputSchema: z.object({
+        workspace_id: z
+            .string()
+            .optional()
+            .describe('Filter to accounts in a specific workspace (get IDs via whoami).'),
+    }),
+    async execute(client, input) {
+        const accounts = await client.listAccounts({ workspace_id: input.workspace_id });
         if (accounts.length === 0) {
-            return 'No connected accounts found. Connect accounts in the posterly dashboard first.';
+            return input.workspace_id
+                ? 'No connected accounts found in this workspace.'
+                : 'No connected accounts found. Connect accounts in the posterly dashboard first.';
         }
-        const lines = accounts.map((a) => `• ${a.platform} — @${a.username} (ID: ${a.id})`);
+        const lines = accounts.map((a) => `• ${a.platform} — @${a.username} (ID: ${a.id}${a.workspace_id ? `, ws: ${a.workspace_id}` : ''})`);
         return `Connected accounts (${accounts.length}):\n${lines.join('\n')}`;
     },
 };

package/dist/tools/list-posts.d.ts

@@ -7,11 +7,14 @@ export declare const listPostsTool: {
         status: z.ZodOptional<z.ZodString>;
         platform: z.ZodOptional<z.ZodString>;
         limit: z.ZodOptional<z.ZodNumber>;
+        workspace_id: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
+        workspace_id?: string | undefined;
         status?: string | undefined;
         platform?: string | undefined;
         limit?: number | undefined;
     }, {
+        workspace_id?: string | undefined;
         status?: string | undefined;
         platform?: string | undefined;
         limit?: number | undefined;
@@ -20,5 +23,6 @@ export declare const listPostsTool: {
         status?: string;
         platform?: string;
         limit?: number;
+        workspace_id?: string;
     }): Promise<string>;
 };

package/dist/tools/list-posts.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export const listPostsTool = {
     name: 'list_posts',
-    description: 'List upcoming or recent posts. Filter by status (scheduled, published, failed, draft) or platform.',
+    description: 'List upcoming or recent posts. Filter by status (scheduled, published, failed, draft), platform, or workspace_id. If workspace_id is omitted, posts across every workspace the caller is a member of are returned.',
     inputSchema: z.object({
         status: z
             .string()
@@ -17,6 +17,10 @@ export const listPostsTool = {
             .max(50)
             .optional()
             .describe('Number of posts to return (default 10, max 50)'),
+        workspace_id: z
+            .string()
+            .optional()
+            .describe('Filter to posts in a specific workspace (get IDs via whoami).'),
     }),
     async execute(client, input) {
         const { posts, total } = await client.listPosts({

package/dist/tools/update-post.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const updatePostTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        post_id: z.ZodNumber;
+        caption: z.ZodOptional<z.ZodString>;
+        scheduled_at: z.ZodOptional<z.ZodString>;
+        media_url: z.ZodOptional<z.ZodString>;
+        media_urls: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        post_type: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        post_id: number;
+        caption?: string | undefined;
+        scheduled_at?: string | undefined;
+        media_url?: string | undefined;
+        media_urls?: string[] | undefined;
+        post_type?: string | undefined;
+    }, {
+        post_id: number;
+        caption?: string | undefined;
+        scheduled_at?: string | undefined;
+        media_url?: string | undefined;
+        media_urls?: string[] | undefined;
+        post_type?: string | undefined;
+    }>;
+    execute(client: PosterlyClient, input: {
+        post_id: number;
+        caption?: string;
+        scheduled_at?: string;
+        media_url?: string;
+        media_urls?: string[];
+        post_type?: string;
+    }): Promise<string>;
+};

package/dist/tools/update-post.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export const updatePostTool = {
+    name: 'update_post',
+    description: 'Update a scheduled or draft post. Can change caption, scheduled time, media, or post type. Cannot edit published or currently publishing posts.',
+    inputSchema: z.object({
+        post_id: z.number().describe('The post ID to update'),
+        caption: z.string().optional().describe('New caption/text content'),
+        scheduled_at: z
+            .string()
+            .optional()
+            .describe('New scheduled time (ISO 8601, e.g. 2026-03-10T09:00:00Z)'),
+        media_url: z.string().optional().describe('New media URL'),
+        media_urls: z.array(z.string()).optional().describe('New media URLs for carousel'),
+        post_type: z
+            .string()
+            .optional()
+            .describe('New post type: text, image, video, carousel, reel, story'),
+    }),
+    async execute(client, input) {
+        const { post_id, ...updates } = input;
+        const result = await client.updatePost(post_id, updates);
+        const p = result.post;
+        const when = p.scheduled_at
+            ? new Date(p.scheduled_at).toLocaleString()
+            : 'N/A';
+        return `Post #${p.id} updated successfully!\n• Status: ${p.status}\n• Caption: ${p.content || '(empty)'}\n• Scheduled: ${when}`;
+    },
+};

package/dist/tools/whoami.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+export declare const whoamiTool: {
+    name: string;
+    description: string;
+    inputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    execute(client: PosterlyClient): Promise<string>;
+};

package/dist/tools/whoami.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export const whoamiTool = {
+    name: 'whoami',
+    description: 'Return the authenticated user, API key scopes, the default (personal) workspace, and every workspace the caller can post in. ALWAYS call this at the start of a session before creating, listing, or scheduling posts — posts created without an explicit workspace_id land in the default workspace shown here, and confirming with the user first prevents posts from appearing in the wrong workspace.',
+    inputSchema: z.object({}),
+    async execute(client) {
+        const info = await client.whoami();
+        const lines = [];
+        lines.push(`User: ${info.user.email || info.user.id}`);
+        lines.push(`API scopes: ${info.api_key.scopes.join(', ') || 'none'}`);
+        lines.push('');
+        lines.push(`Default workspace: ${info.default_workspace.name} (${info.default_workspace.id})` +
+            (info.default_workspace.timezone ? ` — tz: ${info.default_workspace.timezone}` : ''));
+        lines.push('');
+        lines.push(`All workspaces (${info.workspaces.length}):`);
+        for (const ws of info.workspaces) {
+            const marker = ws.id === info.default_workspace.id ? ' [default]' : '';
+            const personal = ws.is_personal ? ' [personal]' : '';
+            const tz = ws.timezone ? ` — tz: ${ws.timezone}` : '';
+            lines.push(`• ${ws.name} — ${ws.id} (role: ${ws.role || 'member'})${personal}${marker}${tz}`);
+        }
+        lines.push('');
+        lines.push('Tip: pass workspace_id to create_post / list_posts / list_accounts / find_available_slot to scope actions to a specific workspace. Omit it to use the default.');
+        return lines.join('\n');
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "posterly-mcp-server",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "MCP server for posterly — schedule social media posts from Claude Desktop",
   "license": "MIT",
   "type": "module",

package/src/index.ts

@@ -8,10 +8,14 @@ import { createPostTool } from './tools/create-post.js';
 import { findSlotTool } from './tools/find-slot.js';
 import { listPostsTool } from './tools/list-posts.js';
 import { uploadMediaTool } from './tools/upload-media.js';
+import { getPostTool } from './tools/get-post.js';
+import { updatePostTool } from './tools/update-post.js';
+import { deletePostTool } from './tools/delete-post.js';
+import { whoamiTool } from './tools/whoami.js';
 
 const server = new McpServer({
   name: 'posterly',
-  version: '0.1.0',
+  version: '0.3.0',
 });
 
 let client: PosterlyClient;
@@ -24,13 +28,27 @@ try {
 }
 
 // Register tools
+server.tool(
+  whoamiTool.name,
+  whoamiTool.description,
+  whoamiTool.inputSchema.shape,
+  async () => {
+    try {
+      const text = await whoamiTool.execute(client);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
 server.tool(
   listAccountsTool.name,
   listAccountsTool.description,
   listAccountsTool.inputSchema.shape,
-  async () => {
+  async (input) => {
     try {
-      const text = await listAccountsTool.execute(client);
+      const text = await listAccountsTool.execute(client, input as any);
       return { content: [{ type: 'text' as const, text }] };
     } catch (err: any) {
       return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
@@ -94,6 +112,48 @@ server.tool(
   }
 );
 
+server.tool(
+  getPostTool.name,
+  getPostTool.description,
+  getPostTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await getPostTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  updatePostTool.name,
+  updatePostTool.description,
+  updatePostTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await updatePostTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
+server.tool(
+  deletePostTool.name,
+  deletePostTool.description,
+  deletePostTool.inputSchema.shape,
+  async (input) => {
+    try {
+      const text = await deletePostTool.execute(client, input as any);
+      return { content: [{ type: 'text' as const, text }] };
+    } catch (err: any) {
+      return { content: [{ type: 'text' as const, text: `Error: ${err.message}` }], isError: true };
+    }
+  }
+);
+
 // Start the server
 async function main() {
   const transport = new StdioServerTransport();

package/src/lib/api-client.ts

@@ -7,6 +7,7 @@ export interface Account {
   username: string;
   account_type?: string;
   profile_picture_url?: string;
+  workspace_id?: string | null;
 }
 
 export interface Post {
@@ -20,6 +21,7 @@ export interface Post {
   post_type?: string;
   platform_post_url?: string;
   published_at?: string;
+  workspace_id?: string | null;
 }
 
 export interface Slot {
@@ -27,6 +29,22 @@ export interface Slot {
   local_time: string;
 }
 
+export interface Workspace {
+  id: string;
+  name: string;
+  slug: string;
+  is_personal: boolean;
+  timezone?: string | null;
+  role?: string;
+}
+
+export interface Whoami {
+  user: { id: string; email: string | null };
+  api_key: { id: string; scopes: string[] };
+  default_workspace: Workspace;
+  workspaces: Workspace[];
+}
+
 export class PosterlyClient {
   private baseUrl: string;
   private apiKey: string;
@@ -69,8 +87,15 @@ export class PosterlyClient {
     return res.json() as Promise<T>;
   }
 
-  async listAccounts(): Promise<Account[]> {
-    const data = await this.request<{ accounts: Account[] }>('GET', '/accounts');
+  async whoami(): Promise<Whoami> {
+    return this.request<Whoami>('GET', '/whoami');
+  }
+
+  async listAccounts(params?: { workspace_id?: string }): Promise<Account[]> {
+    const searchParams = new URLSearchParams();
+    if (params?.workspace_id) searchParams.set('workspace_id', params.workspace_id);
+    const qs = searchParams.toString();
+    const data = await this.request<{ accounts: Account[] }>('GET', `/accounts${qs ? `?${qs}` : ''}`);
     return data.accounts;
   }
 
@@ -79,12 +104,14 @@ export class PosterlyClient {
     platform?: string;
     limit?: number;
     offset?: number;
+    workspace_id?: string;
   }): Promise<{ posts: Post[]; total: number }> {
     const searchParams = new URLSearchParams();
     if (params?.status) searchParams.set('status', params.status);
     if (params?.platform) searchParams.set('platform', params.platform);
     if (params?.limit) searchParams.set('limit', String(params.limit));
     if (params?.offset) searchParams.set('offset', String(params.offset));
+    if (params?.workspace_id) searchParams.set('workspace_id', params.workspace_id);
 
     const qs = searchParams.toString();
     return this.request('GET', `/posts${qs ? `?${qs}` : ''}`);
@@ -100,19 +127,47 @@ export class PosterlyClient {
     media_url?: string;
     media_urls?: string[];
     metadata?: Record<string, unknown>;
-  }): Promise<{ post: Post }> {
+    workspace_id?: string;
+  }): Promise<{
+    post: Post;
+    workspace: { id: string; name: string; is_personal: boolean; resolved_from: 'explicit' | 'account' | 'personal' };
+  }> {
     return this.request('POST', '/posts', data);
   }
 
+  async getPost(id: number): Promise<{ post: Post }> {
+    return this.request('GET', `/posts/${id}`);
+  }
+
+  async updatePost(
+    id: number,
+    data: {
+      caption?: string;
+      scheduled_at?: string;
+      media_url?: string;
+      media_urls?: string[];
+      post_type?: string;
+      metadata?: Record<string, unknown>;
+    },
+  ): Promise<{ post: Post }> {
+    return this.request('PATCH', `/posts/${id}`, data);
+  }
+
+  async deletePost(id: number): Promise<{ deleted: boolean; id: number }> {
+    return this.request('DELETE', `/posts/${id}`);
+  }
+
   async findAvailableSlots(params?: {
     account_ids?: string[];
     timezone?: string;
     count?: number;
+    workspace_id?: string;
   }): Promise<Slot[]> {
     const searchParams = new URLSearchParams();
     if (params?.account_ids?.length) searchParams.set('account_ids', params.account_ids.join(','));
     if (params?.timezone) searchParams.set('timezone', params.timezone);
     if (params?.count) searchParams.set('count', String(params.count));
+    if (params?.workspace_id) searchParams.set('workspace_id', params.workspace_id);
 
     const qs = searchParams.toString();
     const data = await this.request<{ slots: Slot[] }>('GET', `/slots/next${qs ? `?${qs}` : ''}`);

package/src/tools/create-post.ts

@@ -4,7 +4,7 @@ import type { PosterlyClient } from '../lib/api-client.js';
 export const createPostTool = {
   name: 'create_post',
   description:
-    'Schedule or immediately publish a social media post. Provide either account_id OR username+platform to identify the account. If scheduled_at is omitted, the post publishes immediately.',
+    'Schedule or immediately publish a social media post. Provide either account_id OR username+platform to identify the account. If scheduled_at is omitted, the post publishes immediately. IMPORTANT: posts belong to a workspace. If workspace_id is omitted, the server resolves one from the social account, falling back to the caller\'s default (personal) workspace. Call `whoami` first in any new session to confirm which workspace posts will land in, and pass workspace_id explicitly if the user has more than one workspace.',
   inputSchema: z.object({
     account_id: z.string().optional().describe('Social account ID (from list_accounts)'),
     username: z.string().optional().describe('Account username (alternative to account_id)'),
@@ -26,6 +26,10 @@ export const createPostTool = {
       .string()
       .optional()
       .describe('Post type: text, image, video, carousel, reel, story'),
+    workspace_id: z
+      .string()
+      .optional()
+      .describe('Workspace ID to assign the post to (from whoami). If omitted, uses the account\'s workspace or the caller\'s default workspace.'),
   }),
 
   async execute(
@@ -39,15 +43,28 @@ export const createPostTool = {
       media_url?: string;
       media_urls?: string[];
       post_type?: string;
+      workspace_id?: string;
     }
   ) {
     const result = await client.createPost(input);
     const p = result.post as Record<string, any>;
+    const ws = result.workspace;
 
     const when = p.scheduled_at
       ? new Date(p.scheduled_at).toLocaleString()
       : 'now';
 
-    return `Post created successfully!\n• ID: ${p.id}\n• Platform: ${p.platform || input.platform || 'unknown'}\n• Type: ${p.post_type}\n• Status: ${p.status}\n• Scheduled: ${when}`;
+    const lines = [
+      'Post created successfully!',
+      `• ID: ${p.id}`,
+      `• Platform: ${p.platform || input.platform || 'unknown'}`,
+      `• Type: ${p.post_type}`,
+      `• Status: ${p.status}`,
+      `• Scheduled: ${when}`,
+    ];
+    if (ws) {
+      lines.push(`• Workspace: ${ws.name} (${ws.id}) — resolved from ${ws.resolved_from}`);
+    }
+    return lines.join('\n');
   },
 };

package/src/tools/delete-post.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+
+export const deletePostTool = {
+  name: 'delete_post',
+  description:
+    'Delete a scheduled or draft post. Cannot delete published or currently publishing posts.',
+  inputSchema: z.object({
+    post_id: z.number().describe('The post ID to delete'),
+  }),
+
+  async execute(
+    client: PosterlyClient,
+    input: { post_id: number },
+  ) {
+    const result = await client.deletePost(input.post_id);
+    return `Post #${result.id} deleted successfully.`;
+  },
+};

package/src/tools/find-slot.ts

@@ -4,7 +4,7 @@ import type { PosterlyClient } from '../lib/api-client.js';
 export const findSlotTool = {
   name: 'find_available_slot',
   description:
-    'Find available time slots for posting. Respects a 1-hour gap between posts and preferred hours (8am–10pm). Returns up to 10 slots.',
+    'Find available time slots for posting. Respects a 1-hour gap between posts and preferred hours (8am–10pm in the given timezone). Returns up to 10 slots. IMPORTANT: pass a timezone explicitly — default is America/New_York and slots will be off if the user is elsewhere. Pass workspace_id to only avoid collisions with posts in that workspace.',
   inputSchema: z.object({
     account_ids: z
       .array(z.string())
@@ -13,13 +13,17 @@ export const findSlotTool = {
     timezone: z
       .string()
       .optional()
-      .describe('IANA timezone (e.g. America/New_York). Defaults to America/New_York.'),
+      .describe('IANA timezone (e.g. Asia/Dubai, Europe/London). Defaults to America/New_York — pass the user\'s actual timezone or slots will be wrong.'),
     count: z
       .number()
       .min(1)
       .max(10)
       .optional()
       .describe('Number of slots to return (default 5, max 10)'),
+    workspace_id: z
+      .string()
+      .optional()
+      .describe('Scope slot-finding to a single workspace (get IDs via whoami).'),
   }),
 
   async execute(
@@ -28,6 +32,7 @@ export const findSlotTool = {
       account_ids?: string[];
       timezone?: string;
       count?: number;
+      workspace_id?: string;
     }
   ) {
     const slots = await client.findAvailableSlots(input);

package/src/tools/get-post.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+
+export const getPostTool = {
+  name: 'get_post',
+  description:
+    'Get details of a specific post by ID. Returns caption, status, scheduled time, media, and platform info.',
+  inputSchema: z.object({
+    post_id: z.number().describe('The post ID to look up'),
+  }),
+
+  async execute(
+    client: PosterlyClient,
+    input: { post_id: number },
+  ) {
+    const result = await client.getPost(input.post_id);
+    const p = result.post as Record<string, any>;
+
+    const lines = [
+      `Post #${p.id}`,
+      `• Status: ${p.status}`,
+      `• Caption: ${p.content || '(empty)'}`,
+      `• Type: ${p.post_type || 'unknown'}`,
+      `• Scheduled: ${p.scheduled_at ? new Date(p.scheduled_at).toLocaleString() : 'N/A'}`,
+    ];
+
+    if (p.platform_post_url) lines.push(`• Published URL: ${p.platform_post_url}`);
+    if (p.media_url) lines.push(`• Media: ${p.media_url}`);
+    if (p.media_urls?.length) lines.push(`• Media (${p.media_urls.length}): ${p.media_urls.join(', ')}`);
+
+    return lines.join('\n');
+  },
+};

package/src/tools/list-accounts.ts

@@ -3,18 +3,26 @@ import type { PosterlyClient } from '../lib/api-client.js';
 
 export const listAccountsTool = {
   name: 'list_accounts',
-  description: 'List all connected social media accounts. Shows platform, username, and account ID for each.',
-  inputSchema: z.object({}),
+  description:
+    'List connected social media accounts. Returns platform, username, account ID, and workspace ID for each. Pass workspace_id to filter to a specific workspace; otherwise returns all accounts the caller owns across every workspace.',
+  inputSchema: z.object({
+    workspace_id: z
+      .string()
+      .optional()
+      .describe('Filter to accounts in a specific workspace (get IDs via whoami).'),
+  }),
 
-  async execute(client: PosterlyClient) {
-    const accounts = await client.listAccounts();
+  async execute(client: PosterlyClient, input: { workspace_id?: string }) {
+    const accounts = await client.listAccounts({ workspace_id: input.workspace_id });
 
     if (accounts.length === 0) {
-      return 'No connected accounts found. Connect accounts in the posterly dashboard first.';
+      return input.workspace_id
+        ? 'No connected accounts found in this workspace.'
+        : 'No connected accounts found. Connect accounts in the posterly dashboard first.';
     }
 
     const lines = accounts.map(
-      (a) => `• ${a.platform} — @${a.username} (ID: ${a.id})`
+      (a) => `• ${a.platform} — @${a.username} (ID: ${a.id}${a.workspace_id ? `, ws: ${a.workspace_id}` : ''})`
     );
     return `Connected accounts (${accounts.length}):\n${lines.join('\n')}`;
   },

package/src/tools/list-posts.ts

@@ -4,7 +4,7 @@ import type { PosterlyClient } from '../lib/api-client.js';
 export const listPostsTool = {
   name: 'list_posts',
   description:
-    'List upcoming or recent posts. Filter by status (scheduled, published, failed, draft) or platform.',
+    'List upcoming or recent posts. Filter by status (scheduled, published, failed, draft), platform, or workspace_id. If workspace_id is omitted, posts across every workspace the caller is a member of are returned.',
   inputSchema: z.object({
     status: z
       .string()
@@ -20,11 +20,15 @@ export const listPostsTool = {
       .max(50)
       .optional()
       .describe('Number of posts to return (default 10, max 50)'),
+    workspace_id: z
+      .string()
+      .optional()
+      .describe('Filter to posts in a specific workspace (get IDs via whoami).'),
   }),
 
   async execute(
     client: PosterlyClient,
-    input: { status?: string; platform?: string; limit?: number }
+    input: { status?: string; platform?: string; limit?: number; workspace_id?: string }
   ) {
     const { posts, total } = await client.listPosts({
       ...input,

package/src/tools/update-post.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+
+export const updatePostTool = {
+  name: 'update_post',
+  description:
+    'Update a scheduled or draft post. Can change caption, scheduled time, media, or post type. Cannot edit published or currently publishing posts.',
+  inputSchema: z.object({
+    post_id: z.number().describe('The post ID to update'),
+    caption: z.string().optional().describe('New caption/text content'),
+    scheduled_at: z
+      .string()
+      .optional()
+      .describe('New scheduled time (ISO 8601, e.g. 2026-03-10T09:00:00Z)'),
+    media_url: z.string().optional().describe('New media URL'),
+    media_urls: z.array(z.string()).optional().describe('New media URLs for carousel'),
+    post_type: z
+      .string()
+      .optional()
+      .describe('New post type: text, image, video, carousel, reel, story'),
+  }),
+
+  async execute(
+    client: PosterlyClient,
+    input: {
+      post_id: number;
+      caption?: string;
+      scheduled_at?: string;
+      media_url?: string;
+      media_urls?: string[];
+      post_type?: string;
+    },
+  ) {
+    const { post_id, ...updates } = input;
+    const result = await client.updatePost(post_id, updates);
+    const p = result.post as Record<string, any>;
+
+    const when = p.scheduled_at
+      ? new Date(p.scheduled_at).toLocaleString()
+      : 'N/A';
+
+    return `Post #${p.id} updated successfully!\n• Status: ${p.status}\n• Caption: ${p.content || '(empty)'}\n• Scheduled: ${when}`;
+  },
+};

package/src/tools/whoami.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import type { PosterlyClient } from '../lib/api-client.js';
+
+export const whoamiTool = {
+  name: 'whoami',
+  description:
+    'Return the authenticated user, API key scopes, the default (personal) workspace, and every workspace the caller can post in. ALWAYS call this at the start of a session before creating, listing, or scheduling posts — posts created without an explicit workspace_id land in the default workspace shown here, and confirming with the user first prevents posts from appearing in the wrong workspace.',
+  inputSchema: z.object({}),
+
+  async execute(client: PosterlyClient) {
+    const info = await client.whoami();
+
+    const lines: string[] = [];
+    lines.push(`User: ${info.user.email || info.user.id}`);
+    lines.push(`API scopes: ${info.api_key.scopes.join(', ') || 'none'}`);
+    lines.push('');
+    lines.push(
+      `Default workspace: ${info.default_workspace.name} (${info.default_workspace.id})` +
+        (info.default_workspace.timezone ? ` — tz: ${info.default_workspace.timezone}` : '')
+    );
+    lines.push('');
+    lines.push(`All workspaces (${info.workspaces.length}):`);
+    for (const ws of info.workspaces) {
+      const marker = ws.id === info.default_workspace.id ? ' [default]' : '';
+      const personal = ws.is_personal ? ' [personal]' : '';
+      const tz = ws.timezone ? ` — tz: ${ws.timezone}` : '';
+      lines.push(`• ${ws.name} — ${ws.id} (role: ${ws.role || 'member'})${personal}${marker}${tz}`);
+    }
+
+    lines.push('');
+    lines.push(
+      'Tip: pass workspace_id to create_post / list_posts / list_accounts / find_available_slot to scope actions to a specific workspace. Omit it to use the default.'
+    );
+
+    return lines.join('\n');
+  },
+};