@rolino/mcp 0.8.0 → 0.10.0

package/dist/bin.js

@@ -2,7 +2,7 @@
 import {
   resolveMcpConfiguration,
   startStdioServer
-} from "./chunk-SUHHBIE6.js";
+} from "./chunk-OON7OE4T.js";
 
 // src/bin.ts
 async function main() {

package/dist/{chunk-SUHHBIE6.js → chunk-OON7OE4T.js}

@@ -1,4 +1,21 @@
 // src/index.ts
+import { DraftDeletePreviewSchema, DraftDeleteResultSchema } from "@rolino/contracts";
+import {
+  IntegrationDisconnectPreviewSchema,
+  IntegrationDisconnectResultSchema,
+  IntegrationDisconnectExecuteInputSchema,
+  MediaAssetUploadInputSchema,
+  MediaAssetUploadCompleteInputSchema,
+  MediaAssetUploadPreparationSchema,
+  PostScheduleCancelPreviewSchema,
+  PostScheduleCancelResultSchema,
+  PostDeliveryCheckInputSchema,
+  PostDeliveryCheckResultSchema,
+  PostRecoveryInputSchema,
+  PostRecoveryExecuteInputSchema,
+  PostRecoveryPreviewSchema,
+  PostRecoveryResultSchema
+} from "@rolino/contracts";
 import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
 import { McpServer } from "@modelcontextprotocol/server";
 import { openAsBlob } from "fs";
@@ -102,7 +119,7 @@ import * as z from "zod/v4";
 // package.json
 var package_default = {
   name: "@rolino/mcp",
-  version: "0.8.0",
+  version: "0.10.0",
   description: "Model Context Protocol server for Rolino",
   type: "module",
   license: "MIT",
@@ -161,9 +178,9 @@ var package_default = {
   dependencies: {
     "@hono/node-server": "2.0.12",
     "@modelcontextprotocol/server": "2.0.0",
-    "@rolino/contracts": "0.8.0",
-    "@rolino/local-auth": "0.8.0",
-    "@rolino/sdk": "0.8.0",
+    "@rolino/contracts": "0.10.0",
+    "@rolino/local-auth": "0.10.0",
+    "@rolino/sdk": "0.10.0",
     zod: "^4.4.3"
   },
   devDependencies: {
@@ -258,6 +275,7 @@ var mcpDraftInputShape = {
 };
 var mcpDraftUpdateInputShape = {
   ...DraftPostUpdateInputSchema.shape,
+  mediaAltText: DraftPostUpdateInputSchema.shape.mediaAltText.describe("Alternative text keyed by selected asset ID or existing post media ID. Use null to clear. Maximum 1,000 characters. With replacement media, use asset IDs."),
   mediaAssetIds: DraftPostUpdateInputSchema.shape.mediaAssetIds.describe(
     "Replacement ordered media asset IDs. Omit to preserve current media; pass an empty array to remove all media."
   ),
@@ -584,6 +602,34 @@ function createRolinoMcpServer(options = {}) {
       return errorResult(error);
     }
   });
+  server.registerTool("prepare_media_asset_upload", {
+    title: "Prepare a media upload",
+    description: "Requires posts:write. Reserve one user-approved file in the exact project. Return a short-lived upload URL and required headers. Transfer the file bytes to that URL, then call complete_media_asset_upload with the returned storage identity. Keep the upload URL private. This does not create or publish a post and does not read local files on the server.",
+    inputSchema: MediaAssetUploadInputSchema.extend({ projectId: z.string().min(1) }),
+    outputSchema: MediaAssetUploadPreparationSchema,
+    annotations: uploadMediaAnnotations
+  }, async ({ projectId, ...input }) => {
+    try {
+      if (!api.media?.prepareUpload) throw new TypeError("Update the Rolino client for upload preparation.");
+      return jsonResult(await api.media.prepareUpload(projectId, input));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("complete_media_asset_upload", {
+    title: "Verify an uploaded media asset",
+    description: "Requires posts:write. Call after transferring the approved file to the prepared URL. The server verifies stored bytes and media metadata. Use only the returned asset ID in a draft. Failed verification is not a ready asset. This does not create, schedule, or publish a post.",
+    inputSchema: MediaAssetUploadCompleteInputSchema.extend({ projectId: z.string().min(1) }),
+    outputSchema: MediaAssetSchema,
+    annotations: uploadMediaAnnotations
+  }, async ({ projectId, ...input }) => {
+    try {
+      if (!api.media?.completeUpload) throw new TypeError("Update the Rolino client for upload verification.");
+      return jsonResult(await api.media.completeUpload(projectId, input));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
   if ((options.toolProfile ?? "local") === "local") 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.",
@@ -719,6 +765,104 @@ function createRolinoMcpServer(options = {}) {
       return errorResult(error);
     }
   });
+  server.registerTool("check_post_delivery", {
+    title: "Check existing post delivery",
+    description: "Requires posts:write. Read the existing platform upload and update Rolino from that evidence. This never uploads, publishes, or changes visibility. UNKNOWN requires manual review. Missing IDs are not proof that an upload is absent.",
+    inputSchema: PostDeliveryCheckInputSchema.extend({ projectId: z.string().min(1), postId: z.string().min(1) }),
+    outputSchema: PostDeliveryCheckResultSchema,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+  }, async ({ projectId, postId, ...input }) => {
+    try {
+      if (!api.posts.checkDelivery) throw new TypeError("This server does not support delivery checks. Update the server before recovery.");
+      return jsonResult(await api.posts.checkDelivery(projectId, postId, input));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("preview_post_recovery", {
+    title: "Preview existing video recovery",
+    description: "Verify one existing YouTube video and issue a five-minute confirmation. ATTACH links it without publishing. RESUME requires an explicit future publishAt, or null for public visibility now. Requires posts:write and, for RESUME, posts:schedule or posts:publish. Present the video, account, and consequence to the user before execution. No new upload is created.",
+    inputSchema: PostRecoveryInputSchema.safeExtend({ projectId: z.string().min(1), postId: z.string().min(1), expectedVersion: z.number().int().positive() }),
+    outputSchema: PostRecoveryPreviewSchema,
+    annotations: schedulePreviewAnnotations
+  }, async ({ projectId, postId, expectedVersion, ...input }) => {
+    try {
+      if (!api.posts.previewRecovery) throw new TypeError("This server does not support recovery previews. Update the server.");
+      return jsonResult(await api.posts.previewRecovery(projectId, postId, input, { expectedVersion }));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("execute_post_recovery", {
+    title: "Execute confirmed video recovery",
+    description: "Execute only after the user approves preview_post_recovery. Send the unchanged video ID, action, publishAt, post version, and confirmation token. Reuse the same idempotency key on retry. ATTACH does not publish; check delivery afterward. QUEUED means a schedule or publication change is pending, not confirmed. Recovery reuses the existing video and affects only the selected destination.",
+    inputSchema: PostRecoveryExecuteInputSchema.safeExtend({ projectId: z.string().min(1), postId: z.string().min(1), expectedVersion: z.number().int().positive(), idempotencyKey: z.string().min(1).max(200) }),
+    outputSchema: PostRecoveryResultSchema,
+    annotations: scheduleExecuteAnnotations
+  }, async ({ projectId, postId, expectedVersion, idempotencyKey, ...input }) => {
+    try {
+      if (!api.posts.executeRecovery) throw new TypeError("This server does not support recovery execution. Update the server.");
+      return jsonResult(await api.posts.executeRecovery(projectId, postId, input, { expectedVersion, idempotencyKey }));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("preview_draft_deletion", {
+    title: "Preview draft deletion",
+    description: "Requires posts:delete. Preview permanent deletion of one untouched draft. Show its caption, media count, and consequence to the user. Reusable Media Library originals remain.",
+    inputSchema: z.object({ projectId: z.string().min(1), postId: z.string().min(1), expectedVersion: z.number().int().positive() }),
+    outputSchema: DraftDeletePreviewSchema,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
+  }, async ({ projectId, postId, expectedVersion }) => {
+    try {
+      if (!api.posts.previewDeletion) throw new TypeError("Update the Rolino client for draft deletion.");
+      return jsonResult(await api.posts.previewDeletion(projectId, postId, { expectedVersion }));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("execute_draft_deletion", {
+    title: "Delete the confirmed draft",
+    description: "Requires posts:delete and user approval of the exact preview. Permanently delete the untouched draft using its version, confirmation, and stable retry key. Reusable media originals remain. Cannot delete a scheduled or published post.",
+    inputSchema: z.object({ projectId: z.string().min(1), postId: z.string().min(1), expectedVersion: z.number().int().positive(), confirmationToken: z.string().min(1), idempotencyKey: z.string().min(1) }),
+    outputSchema: DraftDeleteResultSchema,
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false }
+  }, async ({ projectId, postId, expectedVersion, confirmationToken, idempotencyKey }) => {
+    try {
+      if (!api.posts.executeDeletion) throw new TypeError("Update the Rolino client for draft deletion.");
+      return jsonResult(await api.posts.executeDeletion(projectId, postId, { confirmationToken }, { expectedVersion, idempotencyKey }));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("preview_post_schedule_cancellation", {
+    title: "Preview post schedule cancellation",
+    description: "Requires posts:schedule. Preview cancellation of all destinations on a future local schedule. Delivery must not have started. Show the post, time, destinations, and consequence to the user. Use check_post_delivery for uncertain delivery.",
+    inputSchema: z.object({ projectId: z.string().min(1), postId: z.string().min(1), expectedVersion: z.number().int().positive() }),
+    outputSchema: PostScheduleCancelPreviewSchema,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
+  }, async ({ projectId, postId, expectedVersion }) => {
+    try {
+      if (!api.posts.previewScheduleCancellation) throw new TypeError("Update the Rolino client for schedule cancellation.");
+      return jsonResult(await api.posts.previewScheduleCancellation(projectId, postId, { expectedVersion }));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("execute_post_schedule_cancellation", {
+    title: "Cancel a confirmed post schedule",
+    description: "Requires posts:schedule and user approval of the exact preview. Return a future local schedule to Draft with the unchanged post version and confirmation. Reuse the idempotency key on retry. Reject started or uncertain delivery; never delete a remote post.",
+    inputSchema: z.object({ projectId: z.string().min(1), postId: z.string().min(1), expectedVersion: z.number().int().positive(), confirmationToken: z.string().min(1), idempotencyKey: z.string().min(1) }),
+    outputSchema: PostScheduleCancelResultSchema,
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false }
+  }, async ({ projectId, postId, expectedVersion, confirmationToken, idempotencyKey }) => {
+    try {
+      if (!api.posts.executeScheduleCancellation) throw new TypeError("Update the Rolino client for schedule cancellation.");
+      return jsonResult(await api.posts.executeScheduleCancellation(projectId, postId, { confirmationToken }, { expectedVersion, idempotencyKey }));
+    } 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. Its preview states that preparation uploads the video privately now; CONFIRMING_SCHEDULE means the upload is complete and YouTube is acknowledging the future Public publish time, not that the video is public. 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.",
@@ -781,16 +925,17 @@ function createRolinoMcpServer(options = {}) {
       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."),
+      destinationIds: PostPublishInputSchema.shape.destinationIds.describe("Exact saved destination IDs from get_post. Required when a network has several accounts. Do not combine with destinations."),
       destinations: PostPublishInputSchema.shape.destinations.describe("Exact Instagram, TikTok, YouTube, Bluesky, and/or LinkedIn destinations to publish now.")
     }),
     outputSchema: PostPublishPreviewSchema,
     annotations: publishPreviewAnnotations
-  }, async ({ projectId, postId, expectedVersion, destinations }) => {
+  }, async ({ projectId, postId, expectedVersion, destinations, destinationIds }) => {
     try {
       return jsonResult(await api.posts.previewPublish(
         projectId,
         postId,
-        { destinations },
+        { destinations, ...destinationIds ? { destinationIds } : {} },
         { expectedVersion }
       ));
     } catch (error) {
@@ -806,6 +951,7 @@ function createRolinoMcpServer(options = {}) {
       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."),
+      destinationIds: PostPublishInputSchema.shape.destinationIds.describe("Exact saved destination IDs from get_post. Required when a network has several accounts. Do not combine with destinations."),
       destinations: PostPublishInputSchema.shape.destinations.describe("Exact unchanged destinations returned by preview_post_publish.")
     }),
     outputSchema: PostSchema,
@@ -816,13 +962,14 @@ function createRolinoMcpServer(options = {}) {
     expectedVersion,
     idempotencyKey,
     confirmationToken,
-    destinations
+    destinations,
+    destinationIds
   }) => {
     try {
       return jsonResult(await api.posts.executePublish(
         projectId,
         postId,
-        { destinations, confirmationToken },
+        { destinations, ...destinationIds ? { destinationIds } : {}, confirmationToken },
         { expectedVersion, idempotencyKey }
       ));
     } catch (error) {
@@ -844,21 +991,50 @@ function createRolinoMcpServer(options = {}) {
       return errorResult(error);
     }
   });
+  server.registerTool("preview_integration_disconnection", {
+    title: "Preview Bluesky disconnection",
+    description: "Requires the separate integrations:disconnect capability. Preview the exact Bluesky account and pending deliveries before user approval. Does not disconnect or expose credentials.",
+    inputSchema: z.object({ projectId: z.string().min(1), integrationId: z.string().min(1).max(200).optional() }),
+    outputSchema: IntegrationDisconnectPreviewSchema,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
+  }, async ({ projectId, integrationId }) => {
+    try {
+      if (!api.integrations.previewDisconnection) throw new TypeError("Update the Rolino client for disconnection.");
+      return jsonResult(await api.integrations.previewDisconnection(projectId, { integrationId }));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("execute_integration_disconnection", {
+    title: "Disconnect the confirmed Bluesky account",
+    description: "Requires integrations:disconnect and user approval of the exact preview. Use its unchanged expectedVersion and confirmation token with a stable idempotency key. Clears local authorization; published posts and saved schedules remain. In-flight delivery can finish. Remote revocation can remain unresolved.",
+    inputSchema: IntegrationDisconnectExecuteInputSchema.extend({ projectId: z.string().min(1), idempotencyKey: z.string().min(1) }),
+    outputSchema: IntegrationDisconnectResultSchema,
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+  }, async ({ projectId, idempotencyKey, ...input }) => {
+    try {
+      if (!api.integrations.executeDisconnection) throw new TypeError("Update the Rolino client for disconnection.");
+      return jsonResult(await api.integrations.executeDisconnection(projectId, input, { idempotencyKey }));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
   server.registerTool("refresh_delivery_options", {
     title: "Refresh provider delivery options",
-    description: "Contact one connected publishing provider and return secret-safe, account-specific choices needed to prepare a compliant draft. TikTok returns account-specific video choices; LinkedIn returns its verified member plus image and native-video policy. This refreshes cached provider health but never creates, schedules, or publishes a post.",
+    description: "Contact one publishing provider and return safe account-specific choices. Bluesky returns text and image limits, connection health, and a human OAuth handoff path on this Rolino host. The owner must approve connection in the browser. TikTok returns video choices; LinkedIn returns member and media policy. This refreshes cached health but never creates, schedules, or publishes a post.",
     inputSchema: z.object({
       projectId: z.string().min(1).describe("Exact Rolino project ID."),
+      integrationId: z.string().min(1).max(200).optional().describe("Exact connection ID returned by integration health."),
       provider: ProviderDeliveryOptionsProviderSchema.describe("Provider whose delivery choices should be refreshed.")
     }),
     outputSchema: ProviderDeliveryOptionsToolSchema,
     annotations: deliveryOptionsAnnotations
-  }, async ({ projectId, provider }) => {
+  }, async ({ projectId, provider, integrationId }) => {
     try {
       if (!api.integrations.deliveryOptions) {
         throw new TypeError("This Rolino client does not support provider delivery options.");
       }
-      return jsonResult(await api.integrations.deliveryOptions(projectId, provider));
+      return jsonResult(await api.integrations.deliveryOptions(projectId, provider, { integrationId }));
     } catch (error) {
       return errorResult(error);
     }
@@ -1612,4 +1788,4 @@ export {
   createRolinoMcpServer,
   startStdioServer
 };
-//# sourceMappingURL=chunk-SUHHBIE6.js.map
+//# sourceMappingURL=chunk-OON7OE4T.js.map