@rolino/mcp 0.1.0

package/dist/index.cjs

@@ -0,0 +1,646 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ROLINO_MCP_VERSION: () => ROLINO_MCP_VERSION,
+  createRolinoMcpServer: () => createRolinoMcpServer,
+  resolveMcpConfiguration: () => resolveMcpConfiguration,
+  startStdioServer: () => startStdioServer
+});
+module.exports = __toCommonJS(index_exports);
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_contracts = require("@rolino/contracts");
+var import_sdk2 = require("@rolino/sdk");
+var z = __toESM(require("zod/v4"), 1);
+
+// package.json
+var package_default = {
+  name: "@rolino/mcp",
+  version: "0.1.0",
+  description: "Model Context Protocol server for Rolino",
+  type: "module",
+  license: "MIT",
+  keywords: [
+    "rolino",
+    "mcp",
+    "model-context-protocol",
+    "social-media",
+    "ai-agent"
+  ],
+  repository: {
+    type: "git",
+    url: "git+https://github.com/deifos/rolino.git",
+    directory: "packages/mcp"
+  },
+  homepage: "https://github.com/deifos/rolino/tree/main/packages/mcp#readme",
+  bugs: {
+    url: "https://github.com/deifos/rolino/issues"
+  },
+  main: "./dist/index.cjs",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  bin: {
+    "rolino-mcp": "./dist/bin.js"
+  },
+  exports: {
+    ".": {
+      import: {
+        types: "./dist/index.d.ts",
+        default: "./dist/index.js"
+      },
+      require: {
+        types: "./dist/index.d.cts",
+        default: "./dist/index.cjs"
+      }
+    }
+  },
+  files: [
+    "dist/**/*.js",
+    "dist/**/*.cjs",
+    "dist/**/*.map",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.cts",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "tsup src/index.ts src/bin.ts --format esm,cjs --dts --sourcemap --clean",
+    typecheck: "tsc --noEmit",
+    dev: "tsx src/bin.ts"
+  },
+  dependencies: {
+    "@hono/node-server": "2.0.12",
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@rolino/contracts": "0.1.0",
+    "@rolino/local-auth": "0.1.0",
+    "@rolino/sdk": "0.1.0",
+    zod: "^4.4.3"
+  },
+  devDependencies: {
+    tsx: "^4.21.0"
+  },
+  engines: {
+    node: ">=20.19.0"
+  }
+};
+
+// src/configuration.ts
+var import_local_auth = require("@rolino/local-auth");
+var import_sdk = require("@rolino/sdk");
+function resolveMcpConfiguration(env = process.env) {
+  const baseUrl = (0, import_sdk.normalizeRolinoBaseUrl)(
+    env.ROLINO_URL ?? "https://getrolino.com"
+  );
+  const credential = (0, import_local_auth.resolveCredential)(baseUrl, env);
+  return {
+    baseUrl,
+    token: credential.token ?? void 0,
+    timeoutMs: env.ROLINO_TIMEOUT ? (0, import_sdk.parseRolinoTimeout)(env.ROLINO_TIMEOUT) : void 0,
+    credentialSource: credential.source
+  };
+}
+
+// src/index.ts
+var ROLINO_MCP_VERSION = package_default.version;
+var mcpDraftInputShape = {
+  ...import_contracts.DraftPostInputSchema.shape,
+  platforms: import_contracts.DraftPostInputSchema.shape.platforms,
+  mediaAssetIds: import_contracts.DraftPostInputSchema.shape.mediaAssetIds.describe(
+    "Existing project media asset IDs. YouTube requires exactly one stored video; Bluesky accepts up to four stored JPEG, PNG, or WebP images."
+  ),
+  captionOverrides: import_contracts.DraftPostInputSchema.shape.captionOverrides.describe(
+    "Optional destination text. YOUTUBE is the video description and BLUESKY is limited to 300 graphemes; when omitted, Rolino uses the shared caption."
+  ),
+  youtubeSettings: import_contracts.DraftPostInputSchema.shape.youtubeSettings.describe(
+    "Required with YOUTUBE: explicit title, numeric categoryId, privacyStatus, madeForKids declaration, synthetic-media disclosure, subscriber-notification choice, and tags. Unaudited Google API projects may be restricted to Private uploads."
+  )
+};
+var mcpScheduleExecuteOutputSchema = z.object({
+  status: z.union([import_contracts.PostSchema.shape.status, z.literal("PENDING")]),
+  id: import_contracts.PostSchema.shape.id.optional(),
+  postId: import_contracts.PostSchedulePendingSchema.shape.postId.optional(),
+  provider: import_contracts.PostSchedulePendingSchema.shape.provider.optional(),
+  mutationId: import_contracts.PostSchedulePendingSchema.shape.mutationId.optional(),
+  operation: import_contracts.PostSchedulePendingSchema.shape.operation.optional(),
+  message: import_contracts.PostSchedulePendingSchema.shape.message.optional()
+}).passthrough();
+function jsonResult(structuredContent) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(structuredContent) }],
+    structuredContent
+  };
+}
+function errorResult(error) {
+  let body;
+  if (error instanceof import_sdk2.RolinoApiError) {
+    body = {
+      error: {
+        code: error.code,
+        message: error.message,
+        ...error.requestId ? { requestId: error.requestId } : {},
+        ...error.retryAfterSeconds === null ? {} : { retryAfterSeconds: error.retryAfterSeconds }
+      }
+    };
+  } else if (error instanceof import_sdk2.RolinoNetworkError) {
+    body = { error: { code: error.kind, message: error.message } };
+  } else if (error instanceof TypeError) {
+    body = { error: { code: "VALIDATION_ERROR", message: error.message } };
+  } else {
+    body = {
+      error: {
+        code: "INTERNAL_ERROR",
+        message: "Rolino could not complete the tool call."
+      }
+    };
+  }
+  return {
+    content: [{ type: "text", text: JSON.stringify(body) }],
+    isError: true
+  };
+}
+var readOnlyAnnotations = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false
+};
+var createDraftAnnotations = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false
+};
+var createProjectAnnotations = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false
+};
+var uploadMediaAnnotations = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: false,
+  openWorldHint: true
+};
+var ProjectCreateToolInputSchema = import_contracts.ProjectCreateInputSchema.safeExtend({
+  idempotencyKey: z.string().min(1).max(200).describe("Stable caller-generated retry key for this exact creation.")
+});
+var updateDraftAnnotations = {
+  readOnlyHint: false,
+  destructiveHint: true,
+  idempotentHint: true,
+  openWorldHint: false
+};
+var schedulePreviewAnnotations = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: false,
+  openWorldHint: true
+};
+var scheduleExecuteAnnotations = {
+  readOnlyHint: false,
+  destructiveHint: true,
+  idempotentHint: true,
+  openWorldHint: true
+};
+var publishPreviewAnnotations = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: false,
+  openWorldHint: true
+};
+var publishExecuteAnnotations = {
+  readOnlyHint: false,
+  destructiveHint: true,
+  idempotentHint: true,
+  openWorldHint: true
+};
+function defaultClient(options) {
+  return new import_sdk2.RolinoClient({
+    baseUrl: options.baseUrl ?? "https://getrolino.com",
+    token: options.token,
+    timeoutMs: options.timeoutMs,
+    fetch: options.fetch
+  });
+}
+function createRolinoMcpServer(options = {}) {
+  const api = options.client ?? defaultClient(options);
+  const server = new import_mcp.McpServer({
+    name: "rolino",
+    version: ROLINO_MCP_VERSION,
+    description: "Read Rolino workspace and publishing state, prepare drafts, and schedule posts through an exact server-confirmed two-step workflow."
+  });
+  server.registerTool("whoami", {
+    title: "Show Rolino identity",
+    description: "Use this before project tools to identify the authenticated Rolino user, organization, and granted capabilities. This tool never changes Rolino data.",
+    inputSchema: {},
+    outputSchema: import_contracts.ActorSchema,
+    annotations: readOnlyAnnotations
+  }, async () => {
+    try {
+      return jsonResult(await api.whoami());
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("list_projects", {
+    title: "List Rolino projects",
+    description: "List projects visible to the authenticated Rolino organization. Use the returned IDs with get_project; paginate with nextCursor when present. This tool never changes Rolino data.",
+    inputSchema: {
+      limit: z.number().int().min(1).max(100).default(50).describe("Maximum number of projects to return, from 1 to 100."),
+      cursor: z.string().min(1).optional().describe("Project cursor returned by a previous list_projects call.")
+    },
+    outputSchema: import_contracts.ProjectListDataSchema,
+    annotations: readOnlyAnnotations
+  }, async ({ limit, cursor }) => {
+    try {
+      return jsonResult(await api.projects.list({ limit, cursor }));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("get_project", {
+    title: "Get a Rolino project",
+    description: "Get one Rolino project by its exact ID after discovering it with list_projects. This tool never changes Rolino data.",
+    inputSchema: {
+      projectId: z.string().min(1).describe("Exact Rolino project ID.")
+    },
+    outputSchema: import_contracts.ProjectSchema,
+    annotations: readOnlyAnnotations
+  }, async ({ projectId }) => {
+    try {
+      return jsonResult(await api.projects.get(projectId));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("create_project", {
+    title: "Create a Rolino project",
+    description: "Create and save one paired Rolino project and brand. This requires projects:write and changes Rolino data, but it does not research a website, connect providers, schedule, or publish. Supply a stable idempotency key so retrying the same input cannot create a duplicate; returned website URLs are normalized and may differ from the submitted string.",
+    inputSchema: ProjectCreateToolInputSchema,
+    outputSchema: import_contracts.ProjectSchema,
+    annotations: createProjectAnnotations
+  }, async ({ idempotencyKey, ...input }) => {
+    try {
+      return jsonResult(await api.projects.create(input, {
+        idempotencyKey
+      }));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("list_media_assets", {
+    title: "List Rolino media assets",
+    description: "List reusable images and videos in one exact project. Use this before uploading to avoid duplicates and pass returned asset IDs when creating or updating drafts. This tool never changes Rolino data.",
+    inputSchema: {
+      projectId: z.string().min(1).describe("Exact Rolino project ID."),
+      limit: z.number().int().min(1).max(100).default(50),
+      cursor: z.string().min(1).optional(),
+      type: z.enum(["IMAGE", "VIDEO"]).optional(),
+      query: z.string().trim().min(1).max(100).optional()
+    },
+    outputSchema: import_contracts.MediaAssetListDataSchema,
+    annotations: readOnlyAnnotations
+  }, async ({ projectId, limit, cursor, type, query }) => {
+    try {
+      if (!api.media) throw new TypeError("This Rolino client does not support media operations.");
+      return jsonResult(await api.media.list(projectId, { limit, cursor, type, query }));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("upload_media_asset", {
+    title: "Upload local media to Rolino",
+    description: "Upload one explicitly approved local JPEG, PNG, WebP, MP4, or MOV file into an exact project's reusable media library. Read only the exact path supplied for this workflow. This changes Rolino data but never creates, schedules, or publishes a post. Return the asset ID for a later draft operation.",
+    inputSchema: {
+      projectId: z.string().min(1).describe("Exact Rolino project ID."),
+      filePath: z.string().min(1).describe("Exact local path of the user-approved media file.")
+    },
+    outputSchema: import_contracts.MediaAssetSchema,
+    annotations: uploadMediaAnnotations
+  }, async ({ projectId, filePath }) => {
+    try {
+      if (!api.media) throw new TypeError("This Rolino client does not support media operations.");
+      const absolutePath = (0, import_node_path.resolve)(filePath);
+      const details = await (0, import_promises.stat)(absolutePath).catch(() => null);
+      if (!details?.isFile()) throw new TypeError("The media path must point to a readable file.");
+      const contentTypes = { ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".png": "image/png", ".webp": "image/webp", ".mp4": "video/mp4", ".mov": "video/quicktime" };
+      const contentType = contentTypes[(0, import_node_path.extname)(absolutePath).toLowerCase()];
+      if (!contentType) throw new TypeError("Use a JPEG, PNG, WebP, MP4, or MOV file.");
+      const bytes = await (0, import_promises.readFile)(absolutePath);
+      return jsonResult(await api.media.upload(projectId, { fileName: (0, import_node_path.basename)(absolutePath), contentType, fileSize: details.size, body: new Blob([bytes], { type: contentType }) }));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("list_posts", {
+    title: "List Rolino posts",
+    description: "List posts in an exact Rolino project. Discover project IDs with list_projects, filter by status when useful, and paginate with nextCursor. This tool never changes Rolino data.",
+    inputSchema: {
+      projectId: z.string().min(1).describe("Exact Rolino project ID."),
+      limit: z.number().int().min(1).max(100).default(50).describe("Maximum number of posts to return, from 1 to 100."),
+      cursor: z.string().min(1).optional().describe("Post cursor returned by a previous list_posts call."),
+      status: z.enum([
+        "DRAFT",
+        "SCHEDULED",
+        "ACTION_REQUIRED",
+        "PUBLISHING",
+        "PUBLISHED",
+        "PARTIALLY_PUBLISHED",
+        "FAILED"
+      ]).optional().describe("Optional exact post status filter.")
+    },
+    outputSchema: import_contracts.PostListDataSchema,
+    annotations: readOnlyAnnotations
+  }, async ({ projectId, limit, cursor, status }) => {
+    try {
+      return jsonResult(await api.posts.list(projectId, {
+        limit,
+        cursor,
+        status
+      }));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("get_post", {
+    title: "Get a Rolino post",
+    description: "Get one Rolino post, including its ordered media and publication-destination status, by exact project and post IDs. This tool never changes Rolino data.",
+    inputSchema: {
+      projectId: z.string().min(1).describe("Exact Rolino project ID."),
+      postId: z.string().min(1).describe("Exact Rolino post ID.")
+    },
+    outputSchema: import_contracts.PostSchema,
+    annotations: readOnlyAnnotations
+  }, async ({ projectId, postId }) => {
+    try {
+      return jsonResult(await api.posts.get(projectId, postId));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("create_draft_post", {
+    title: "Create Rolino draft post",
+    description: "Create a draft in one exact project. This changes Rolino data but never schedules or publishes. A YouTube draft requires exactly one stored video plus explicit title, category, visibility, audience, disclosure, notification, and tag settings; its description uses the YOUTUBE caption override or shared caption. Unaudited Google API projects may be limited to Private uploads. Supply a stable idempotency key so retrying the same input cannot create a duplicate.",
+    inputSchema: {
+      projectId: z.string().min(1).describe("Exact Rolino project ID."),
+      idempotencyKey: z.string().min(1).max(200).describe("Stable caller-generated retry key for this exact creation."),
+      ...mcpDraftInputShape
+    },
+    outputSchema: import_contracts.PostSchema,
+    annotations: createDraftAnnotations
+  }, async ({ projectId, idempotencyKey, ...input }) => {
+    try {
+      const draft = import_contracts.DraftPostInputSchema.parse(input);
+      return jsonResult(await api.posts.create(projectId, draft, {
+        idempotencyKey
+      }));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("update_draft_post", {
+    title: "Update Rolino draft post",
+    description: "Replace a draft's caption, destinations, media, and provider settings without scheduling or publishing it. YouTube still requires exactly one stored video and every explicit metadata declaration; its description uses the YOUTUBE caption override or shared caption. Read the post first and pass its current version; stale versions fail instead of overwriting another change. A stable idempotency key makes exact retries safe.",
+    inputSchema: {
+      projectId: z.string().min(1).describe("Exact Rolino project ID."),
+      postId: z.string().min(1).describe("Exact Rolino draft post ID."),
+      expectedVersion: z.number().int().positive().describe("Current version returned by get_post."),
+      idempotencyKey: z.string().min(1).max(200).describe("Stable caller-generated retry key for this exact update."),
+      ...mcpDraftInputShape
+    },
+    outputSchema: import_contracts.PostSchema,
+    annotations: updateDraftAnnotations
+  }, async ({
+    projectId,
+    postId,
+    expectedVersion,
+    idempotencyKey,
+    ...input
+  }) => {
+    try {
+      const draft = import_contracts.DraftPostInputSchema.parse(input);
+      return jsonResult(await api.posts.update(projectId, postId, draft, {
+        expectedVersion,
+        idempotencyKey
+      }));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("get_post_readiness", {
+    title: "Get Rolino post readiness",
+    description: "Evaluate one saved post against its destinations, media, captions, settings, permissions, token timing, and cached provider health. YouTube checks cover one stored video, explicit metadata and declarations, description limits, Private-only audit restrictions, and queue-aware lead time. This is a read-only evaluation and does not refresh providers or publish content.",
+    inputSchema: {
+      projectId: z.string().min(1).describe("Exact Rolino project ID."),
+      postId: z.string().min(1).describe("Exact Rolino post ID.")
+    },
+    outputSchema: import_contracts.PostReadinessSchema,
+    annotations: readOnlyAnnotations
+  }, async ({ projectId, postId }) => {
+    try {
+      return jsonResult(await api.posts.readiness(projectId, postId));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("preview_post_schedule", {
+    title: "Preview a Rolino post schedule",
+    description: "Validate one exact future schedule against the current post version and live provider health. A YouTube schedule must target Public and its preview explains that confirmed execution starts a private upload immediately for early processing. This contacts configured providers and creates a five-minute, single-use confirmation, but does not schedule or publish the post. Inspect the complete result before calling execute_post_schedule with identical values.",
+    inputSchema: {
+      projectId: z.string().min(1).describe("Exact Rolino project ID."),
+      postId: z.string().min(1).describe("Exact Rolino post ID."),
+      expectedVersion: z.number().int().positive().describe("Current version returned by get_post."),
+      ...import_contracts.PostScheduleInputSchema.shape
+    },
+    outputSchema: import_contracts.PostSchedulePreviewSchema,
+    annotations: schedulePreviewAnnotations
+  }, async ({ projectId, postId, expectedVersion, ...input }) => {
+    try {
+      return jsonResult(await api.posts.previewSchedule(
+        projectId,
+        postId,
+        input,
+        { expectedVersion }
+      ));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("execute_post_schedule", {
+    title: "Execute a confirmed Rolino post schedule",
+    description: "Schedule a post only after preview_post_schedule. Pass the unchanged time, timezone, post version, and returned one-time confirmation token. For YouTube, confirmed execution begins or resumes the private upload immediately and may return PENDING until a remote schedule change is confirmed; it never means the video already published. Rolino rechecks readiness and provider health, rejects stale or mismatched confirmation, and uses the stable idempotency key for safe retries. Scheduling causes future external publishing and is consequential.",
+    inputSchema: {
+      projectId: z.string().min(1).describe("Exact Rolino project ID."),
+      postId: z.string().min(1).describe("Exact Rolino post ID."),
+      expectedVersion: z.number().int().positive().describe("Same post version used by preview_post_schedule."),
+      idempotencyKey: z.string().min(1).max(200).describe("Stable caller-generated retry key for this exact execution."),
+      confirmationToken: z.string().min(1).max(200).describe("Single-use token returned by preview_post_schedule."),
+      ...import_contracts.PostScheduleInputSchema.shape
+    },
+    outputSchema: mcpScheduleExecuteOutputSchema,
+    annotations: scheduleExecuteAnnotations
+  }, async ({
+    projectId,
+    postId,
+    expectedVersion,
+    idempotencyKey,
+    confirmationToken,
+    ...input
+  }) => {
+    try {
+      return jsonResult(await api.posts.executeSchedule(
+        projectId,
+        postId,
+        { ...input, confirmationToken },
+        { expectedVersion, idempotencyKey }
+      ));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("preview_post_publish", {
+    title: "Preview immediate Rolino post publishing",
+    description: "Validate exact destinations against the current post version, safe retry state, readiness, and live provider health. YouTube readiness requires one stored video and explicit metadata; the configured visibility is exact, while unaudited Google API projects may be restricted to Private. This contacts configured providers and creates a five-minute, single-use confirmation, but does not publish. Inspect the complete result before calling execute_post_publish with identical destinations.",
+    inputSchema: {
+      projectId: z.string().min(1).describe("Exact Rolino project ID."),
+      postId: z.string().min(1).describe("Exact Rolino post ID."),
+      expectedVersion: z.number().int().positive().describe("Current version returned by get_post."),
+      destinations: import_contracts.PostPublishInputSchema.shape.destinations.describe("Exact Instagram, TikTok, YouTube, and/or Bluesky destinations to publish now.")
+    },
+    outputSchema: import_contracts.PostPublishPreviewSchema,
+    annotations: publishPreviewAnnotations
+  }, async ({ projectId, postId, expectedVersion, destinations }) => {
+    try {
+      return jsonResult(await api.posts.previewPublish(
+        projectId,
+        postId,
+        { destinations },
+        { expectedVersion }
+      ));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("execute_post_publish", {
+    title: "Execute confirmed immediate Rolino post publishing",
+    description: "Begin external publishing only after preview_post_publish. Pass the unchanged destinations, post version, and returned one-time confirmation token. YouTube execution starts a resumable upload and remains PREPARING until provider-confirmed upload and processing complete; no queued or local state is reported as published. Rolino rechecks readiness and safe retry state, durably queues the exact destinations, rejects ambiguous prior outcomes, and uses the stable idempotency key to prevent duplicate execution. This is immediately consequential.",
+    inputSchema: {
+      projectId: z.string().min(1).describe("Exact Rolino project ID."),
+      postId: z.string().min(1).describe("Exact Rolino post ID."),
+      expectedVersion: z.number().int().positive().describe("Same post version used by preview_post_publish."),
+      idempotencyKey: z.string().min(1).max(200).describe("Stable caller-generated retry key for this exact execution."),
+      confirmationToken: z.string().min(1).max(200).describe("Single-use token returned by preview_post_publish."),
+      destinations: import_contracts.PostPublishInputSchema.shape.destinations.describe("Exact unchanged destinations returned by preview_post_publish.")
+    },
+    outputSchema: import_contracts.PostSchema,
+    annotations: publishExecuteAnnotations
+  }, async ({
+    projectId,
+    postId,
+    expectedVersion,
+    idempotencyKey,
+    confirmationToken,
+    destinations
+  }) => {
+    try {
+      return jsonResult(await api.posts.executePublish(
+        projectId,
+        postId,
+        { destinations, confirmationToken },
+        { expectedVersion, idempotencyKey }
+      ));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("list_integration_health", {
+    title: "List Rolino publishing integration health",
+    description: "List secret-safe cached health for every enabled publishing connection (Instagram, TikTok, YouTube, or Bluesky) in one exact project. This tool does not contact external providers or reveal social credentials.",
+    inputSchema: {
+      projectId: z.string().min(1).describe("Exact Rolino project ID.")
+    },
+    outputSchema: import_contracts.IntegrationHealthListDataSchema,
+    annotations: readOnlyAnnotations
+  }, async ({ projectId }) => {
+    try {
+      return jsonResult(await api.integrations.health(projectId));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("list_calendar_events", {
+    title: "List Rolino calendar events",
+    description: "List scheduled posts and their enabled destinations in one exact project, including YouTube posts whose private early preparation has started. By default the bounded window spans 30 days in the past through 90 days ahead; provide both from and to for another range and paginate with nextCursor.",
+    inputSchema: {
+      projectId: z.string().min(1).describe("Exact Rolino project ID."),
+      limit: z.number().int().min(1).max(100).default(50).describe("Maximum number of calendar events to return, from 1 to 100."),
+      cursor: z.string().min(1).optional().describe("Opaque cursor returned by a previous list_calendar_events call."),
+      from: z.iso.datetime().optional().describe("Inclusive ISO-8601 window start; provide together with to."),
+      to: z.iso.datetime().optional().describe("Exclusive ISO-8601 window end; provide together with from.")
+    },
+    outputSchema: import_contracts.CalendarListDataSchema,
+    annotations: readOnlyAnnotations
+  }, async ({ projectId, limit, cursor, from, to }) => {
+    try {
+      return jsonResult(await api.calendar.list(projectId, {
+        limit,
+        cursor,
+        from,
+        to
+      }));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  return server;
+}
+async function startStdioServer(options = {}) {
+  const server = createRolinoMcpServer(options);
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+  return server;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ROLINO_MCP_VERSION,
+  createRolinoMcpServer,
+  resolveMcpConfiguration,
+  startStdioServer
+});
+//# sourceMappingURL=index.cjs.map