@anaella/mcp 0.1.0

package/README.md

@@ -0,0 +1,90 @@
+# @anaella/mcp
+
+An MCP (Model Context Protocol) server for [anaella.com](https://anaella.com) — schedule and
+publish social posts to your connected channels via the anaella `/v1` API, from any MCP client
+(Claude, Claude Code, Cursor, etc.).
+
+It's hosted at `https://api.anaella.com/mcp` (Streamable HTTP), or you can run it locally over
+stdio.
+
+## Client configuration
+
+Remote (recommended):
+```json
+{ "mcpServers": { "anaella": {
+  "url": "https://api.anaella.com/mcp",
+  "headers": { "Authorization": "Bearer ana_..." }
+}}}
+```
+
+Local (stdio):
+```json
+{ "mcpServers": { "anaella": {
+  "command": "npx", "args": ["-y", "@anaella/mcp"],
+  "env": { "ANAELLA_API_KEY": "ana_..." }
+}}}
+```
+
+Get an API key (`ana_...`) from your anaella organization settings.
+
+## Tools
+
+- **list_channels** — List the connected social channels for your organization. Call this
+  first to get the channel ids you pass to `create_post`.
+- **create_post** — Create and (optionally) publish a post to one or more channels.
+  - `channels: string[]` (required) — channel ids from `list_channels`
+  - `text?: string` — post text / caption
+  - `when?: string` — `"now"` publishes immediately, `"draft"` (default) saves without
+    publishing, or an ISO-8601 timestamp schedules it
+  - `media?: { url: string }[]` — public file URLs the API downloads
+  - `type?: "post" | "reel" | "thread" | "story"` — defaults to `"post"`
+  - `firstComment?: string`
+  - Publishing is asynchronous — poll `get_post` for the final per-channel status.
+- **list_posts** — List recent posts for your organization with their per-channel status.
+  - `limit?: number` (1-100), `cursor?: number`
+- **get_post** — Get one post by id, including its per-channel publish status.
+  - `id: string`
+- **delete_post** — Delete a draft or cancel a scheduled post by id.
+  - `id: string`
+
+## Environment variables
+
+- `ANAELLA_API_KEY` — required for stdio mode; your `ana_...` API key.
+- `ANAELLA_API_URL` — base URL for the anaella API. Defaults to `https://api.anaella.com`.
+
+In remote (Streamable HTTP) mode the API key is instead passed per-request as an
+`Authorization: Bearer ana_...` header.
+
+## Local development
+
+```bash
+bun install
+bun run build        # tsup -> dist/index.js (stdio) + dist/http.js (Streamable HTTP)
+bun run dev           # tsup --watch
+bun test
+```
+
+## Smoke test
+
+`bun run smoke` runs an opt-in, live smoke test against a real anaella API: it lists your
+channels, creates a **draft** post (never publishes), then deletes it. It's a no-op unless
+`ANAELLA_SMOKE_KEY` is set to a real `ana_...` key.
+
+```bash
+ANAELLA_SMOKE_KEY=ana_... ANAELLA_API_URL=https://api.anaella.com bun run smoke
+```
+
+## Docker
+
+Build context is this package directory (`packages/mcp`) — the image is self-contained and has
+no `@anaella/*` workspace dependencies to resolve.
+
+```bash
+cd packages/mcp
+docker build -t anaella-mcp:local .
+docker run -d -p 3000:3000 -e ANAELLA_API_URL=https://api.anaella.com anaella-mcp:local
+curl http://localhost:3000/health   # -> ok
+```
+
+The container runs the Streamable HTTP server (`node dist/http.js`), exposing `GET /health`
+and `POST /mcp` (requires `Authorization: Bearer ana_...`).

package/dist/chunk-GXJ2ADGM.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+
+// src/client.ts
+var AnaellaApiError = class extends Error {
+  constructor(status, code, message, details) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.details = details;
+    this.name = "AnaellaApiError";
+  }
+  status;
+  code;
+  details;
+};
+var AnaellaClient = class {
+  apiKey;
+  baseUrl;
+  constructor(opts) {
+    this.apiKey = opts.apiKey;
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+  }
+  async request(method, path, body) {
+    let res;
+    try {
+      res = await fetch(this.baseUrl + path, {
+        method,
+        headers: {
+          authorization: `Bearer ${this.apiKey}`,
+          ...body === void 0 ? {} : { "content-type": "application/json" }
+        },
+        body: body === void 0 ? void 0 : JSON.stringify(body)
+      });
+    } catch (e) {
+      throw new AnaellaApiError(
+        0,
+        "network_error",
+        `Could not reach anaella API: ${e.message}`
+      );
+    }
+    const raw = await res.text();
+    let json;
+    try {
+      json = raw ? JSON.parse(raw) : void 0;
+    } catch {
+      json = void 0;
+    }
+    if (!res.ok) {
+      const env = json?.error;
+      throw new AnaellaApiError(
+        res.status,
+        env?.code ?? "error",
+        env?.message ?? `HTTP ${res.status}${raw ? `: ${raw.slice(0, 200)}` : ""}`,
+        env?.details
+      );
+    }
+    return json;
+  }
+  listChannels() {
+    return this.request("GET", "/v1/channels");
+  }
+  createPost(body) {
+    return this.request("POST", "/v1/posts", body);
+  }
+  listPosts(opts = {}) {
+    const q = new URLSearchParams();
+    if (opts.limit !== void 0) q.set("limit", String(opts.limit));
+    if (opts.cursor !== void 0) q.set("cursor", String(opts.cursor));
+    const qs = q.toString();
+    return this.request("GET", `/v1/posts${qs ? `?${qs}` : ""}`);
+  }
+  getPost(id) {
+    return this.request("GET", `/v1/posts/${encodeURIComponent(id)}`);
+  }
+  deletePost(id) {
+    return this.request("DELETE", `/v1/posts/${encodeURIComponent(id)}`);
+  }
+};
+
+// src/config.ts
+function loadConfig(env) {
+  return {
+    apiKey: env.ANAELLA_API_KEY,
+    apiUrl: env.ANAELLA_API_URL?.replace(/\/+$/, "") || "https://api.anaella.com"
+  };
+}
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/tools.ts
+import { z } from "zod";
+var ok = (data) => ({
+  content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+});
+var fail = (err) => {
+  if (err instanceof AnaellaApiError) {
+    const detail = err.details?.length ? `
+Details: ${JSON.stringify(err.details)}` : "";
+    return {
+      content: [{ type: "text", text: `Error [${err.code}] (HTTP ${err.status}): ${err.message}${detail}` }],
+      isError: true
+    };
+  }
+  return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+};
+var wrap = (fn) => async (args) => {
+  try {
+    return ok(await fn(args));
+  } catch (err) {
+    return fail(err);
+  }
+};
+function buildTools(client) {
+  return [
+    {
+      name: "list_channels",
+      config: {
+        description: "List the connected social channels for your organization. Call this FIRST to get the channel ids you pass to create_post.",
+        inputSchema: {}
+      },
+      handler: wrap(() => client.listChannels())
+    },
+    {
+      name: "create_post",
+      config: {
+        description: 'Create and (optionally) publish a post to one or more channels. Get channel ids from list_channels first. `when`: "now" publishes immediately, "draft" (default) saves without publishing, or an ISO-8601 timestamp schedules it. `media` are PUBLIC file URLs the API downloads. Publishing is asynchronous \u2014 poll get_post for the final per-channel status.',
+        inputSchema: {
+          channels: z.array(z.string()).min(1).describe("Channel ids from list_channels"),
+          text: z.string().optional().describe("Post text / caption"),
+          when: z.string().optional().describe('"now" | "draft" | ISO-8601 timestamp'),
+          media: z.array(z.object({ url: z.string().url() })).optional().describe("Public media URLs"),
+          type: z.enum(["post", "reel", "thread", "story"]).optional().describe('Defaults to "post"'),
+          firstComment: z.string().max(2e3).optional()
+        }
+      },
+      handler: wrap((args) => client.createPost(args))
+    },
+    {
+      name: "list_posts",
+      config: {
+        description: "List recent posts for your organization with their per-channel status.",
+        inputSchema: {
+          limit: z.number().int().min(1).max(100).optional(),
+          cursor: z.number().int().min(0).optional()
+        }
+      },
+      handler: wrap((args) => client.listPosts(args))
+    },
+    {
+      name: "get_post",
+      config: {
+        description: "Get one post by id, including its per-channel publish status. Use to poll after create_post.",
+        inputSchema: { id: z.string() }
+      },
+      handler: wrap((args) => client.getPost(args.id))
+    },
+    {
+      name: "delete_post",
+      config: {
+        description: "Delete a draft or cancel a scheduled post by id.",
+        inputSchema: { id: z.string() }
+      },
+      handler: wrap((args) => client.deletePost(args.id))
+    }
+  ];
+}
+
+// src/server.ts
+function buildServer(client) {
+  const server = new McpServer({ name: "anaella", version: "0.1.0" });
+  for (const tool of buildTools(client)) {
+    server.registerTool(tool.name, tool.config, tool.handler);
+  }
+  return server;
+}
+
+export {
+  AnaellaClient,
+  loadConfig,
+  buildServer
+};

package/dist/http.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import {
+  AnaellaClient,
+  buildServer,
+  loadConfig
+} from "./chunk-GXJ2ADGM.js";
+
+// src/http.ts
+import http from "http";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+function readBody(req) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => {
+      const raw = Buffer.concat(chunks).toString("utf8");
+      if (!raw) return resolve(void 0);
+      try {
+        resolve(JSON.parse(raw));
+      } catch {
+        resolve(void 0);
+      }
+    });
+    req.on("error", () => resolve(void 0));
+  });
+}
+function sendJson(res, status, body) {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+function createHttpServer(apiUrl) {
+  return http.createServer(async (req, res) => {
+    const url = req.url ?? "";
+    if (req.method === "GET" && url === "/health") {
+      res.writeHead(200, { "content-type": "text/plain" });
+      res.end("ok");
+      return;
+    }
+    if (!url.startsWith("/mcp")) {
+      sendJson(res, 404, { error: { code: "not_found", message: "Not found" } });
+      return;
+    }
+    const authz = req.headers.authorization ?? "";
+    if (!/^Bearer\s+ana_/i.test(authz)) {
+      sendJson(res, 401, {
+        error: { code: "unauthorized", message: "Authorization: Bearer ana_\u2026 is required" }
+      });
+      return;
+    }
+    const apiKey = authz.replace(/^Bearer\s+/i, "");
+    const body = req.method === "POST" ? await readBody(req) : void 0;
+    const client = new AnaellaClient({ apiKey, baseUrl: apiUrl });
+    const server = buildServer(client);
+    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
+    res.on("close", () => {
+      transport.close();
+      server.close();
+    });
+    try {
+      await server.connect(transport);
+      await transport.handleRequest(req, res, body);
+    } catch (err) {
+      process.stderr.write(`[anaella-mcp] request error: ${err.message}
+`);
+      if (!res.headersSent) {
+        sendJson(res, 500, { error: { code: "internal", message: "Internal error" } });
+      }
+    }
+  });
+}
+function main() {
+  const { apiUrl } = loadConfig(process.env);
+  const port = Number(process.env.PORT) || 3e3;
+  const server = createHttpServer(apiUrl);
+  server.listen(port, () => {
+    process.stderr.write(`[anaella-mcp] HTTP server listening on :${port} \u2192 ${apiUrl}
+`);
+  });
+}
+if (process.argv[1] && (process.argv[1].endsWith("http.ts") || process.argv[1].endsWith("http.js"))) {
+  main();
+}
+export {
+  createHttpServer
+};

package/dist/index.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import {
+  AnaellaClient,
+  buildServer,
+  loadConfig
+} from "./chunk-GXJ2ADGM.js";
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+async function main() {
+  const { apiKey, apiUrl } = loadConfig(process.env);
+  if (!apiKey) {
+    process.stderr.write(
+      "[anaella-mcp] ANAELLA_API_KEY is required (a developer key like ana_\u2026).\n"
+    );
+    process.exit(1);
+  }
+  const client = new AnaellaClient({ apiKey, baseUrl: apiUrl });
+  const server = buildServer(client);
+  await server.connect(new StdioServerTransport());
+  process.stderr.write(`[anaella-mcp] stdio server ready \u2192 ${apiUrl}
+`);
+}
+main().catch((err) => {
+  process.stderr.write(`[anaella-mcp] fatal: ${err.message}
+`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@anaella/mcp",
+  "version": "0.1.0",
+  "description": "MCP server for anaella.com — schedule and publish social posts via the /v1 API.",
+  "type": "module",
+  "bin": { "anaella-mcp": "dist/index.js" },
+  "files": ["dist"],
+  "publishConfig": { "access": "public" },
+  "scripts": {
+    "build": "tsup",
+    "prepublishOnly": "npm run build",
+    "dev": "tsup --watch",
+    "test": "bun test",
+    "smoke": "bun run src/smoke.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5",
+    "@types/node": "^22"
+  }
+}