@sync.so/mcp-server 0.1.3 → 0.2.0

package/dist/tools/studio-view-contract.d.ts

@@ -0,0 +1,184 @@
+import { z } from 'zod';
+export declare const StudioViewContextSchema: z.ZodObject<{
+    projectId: z.ZodNullable<z.ZodUUID>;
+    draftId: z.ZodNullable<z.ZodUUID>;
+    draftRevision: z.ZodNullable<z.ZodNumber>;
+    editToken: z.ZodOptional<z.ZodString>;
+    busy: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const StudioViewCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"open-project">;
+    projectId: z.ZodUUID;
+    workflow: z.ZodOptional<z.ZodEnum<{
+        edit_dialogue: "edit_dialogue";
+        image_to_video: "image_to_video";
+        lipsync: "lipsync";
+        translate_and_dub: "translate_and_dub";
+    }>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"refresh-project">;
+    projectId: z.ZodUUID;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"refresh-assets">;
+    projectId: z.ZodUUID;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"open-generation">;
+    projectId: z.ZodUUID;
+    generationId: z.ZodUUID;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"continue-generation">;
+    projectId: z.ZodUUID;
+    generationId: z.ZodUUID;
+    workflow: z.ZodEnum<{
+        edit_dialogue: "edit_dialogue";
+        image_to_video: "image_to_video";
+        lipsync: "lipsync";
+        translate_and_dub: "translate_and_dub";
+    }>;
+    seedSource: z.ZodEnum<{
+        output: "output";
+        "source-input": "source-input";
+    }>;
+}, z.core.$strict>], "type">;
+export declare const StudioViewSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    revision: z.ZodNumber;
+    context: z.ZodObject<{
+        projectId: z.ZodNullable<z.ZodUUID>;
+        draftId: z.ZodNullable<z.ZodUUID>;
+        draftRevision: z.ZodNullable<z.ZodNumber>;
+        editToken: z.ZodOptional<z.ZodString>;
+        busy: z.ZodBoolean;
+    }, z.core.$strict>;
+    updatedAt: z.ZodNumber;
+    action: z.ZodNullable<z.ZodObject<{
+        id: z.ZodUUID;
+        requestRevision: z.ZodNumber;
+        expectedContext: z.ZodObject<{
+            projectId: z.ZodNullable<z.ZodUUID>;
+            draftId: z.ZodNullable<z.ZodUUID>;
+            draftRevision: z.ZodNullable<z.ZodNumber>;
+            editToken: z.ZodOptional<z.ZodString>;
+            busy: z.ZodBoolean;
+        }, z.core.$strict>;
+        command: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"open-project">;
+            projectId: z.ZodUUID;
+            workflow: z.ZodOptional<z.ZodEnum<{
+                edit_dialogue: "edit_dialogue";
+                image_to_video: "image_to_video";
+                lipsync: "lipsync";
+                translate_and_dub: "translate_and_dub";
+            }>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"refresh-project">;
+            projectId: z.ZodUUID;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"refresh-assets">;
+            projectId: z.ZodUUID;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"open-generation">;
+            projectId: z.ZodUUID;
+            generationId: z.ZodUUID;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"continue-generation">;
+            projectId: z.ZodUUID;
+            generationId: z.ZodUUID;
+            workflow: z.ZodEnum<{
+                edit_dialogue: "edit_dialogue";
+                image_to_video: "image_to_video";
+                lipsync: "lipsync";
+                translate_and_dub: "translate_and_dub";
+            }>;
+            seedSource: z.ZodEnum<{
+                output: "output";
+                "source-input": "source-input";
+            }>;
+        }, z.core.$strict>], "type">;
+        expiresAt: z.ZodNumber;
+        status: z.ZodEnum<{
+            applied: "applied";
+            blocked: "blocked";
+            failed: "failed";
+            pending: "pending";
+        }>;
+        reason: z.ZodOptional<z.ZodEnum<{
+            busy: "busy";
+            expired: "expired";
+            stale: "stale";
+            unavailable: "unavailable";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const RegisterStudioViewSchema: z.ZodObject<{
+    mountId: z.ZodUUID;
+    claim: z.ZodDefault<z.ZodBoolean>;
+    context: z.ZodObject<{
+        projectId: z.ZodNullable<z.ZodUUID>;
+        draftId: z.ZodNullable<z.ZodUUID>;
+        draftRevision: z.ZodNullable<z.ZodNumber>;
+        editToken: z.ZodOptional<z.ZodString>;
+        busy: z.ZodBoolean;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const RequestStudioViewActionSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    expectedRevision: z.ZodNumber;
+    command: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"open-project">;
+        projectId: z.ZodUUID;
+        workflow: z.ZodOptional<z.ZodEnum<{
+            edit_dialogue: "edit_dialogue";
+            image_to_video: "image_to_video";
+            lipsync: "lipsync";
+            translate_and_dub: "translate_and_dub";
+        }>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"refresh-project">;
+        projectId: z.ZodUUID;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"refresh-assets">;
+        projectId: z.ZodUUID;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"open-generation">;
+        projectId: z.ZodUUID;
+        generationId: z.ZodUUID;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"continue-generation">;
+        projectId: z.ZodUUID;
+        generationId: z.ZodUUID;
+        workflow: z.ZodEnum<{
+            edit_dialogue: "edit_dialogue";
+            image_to_video: "image_to_video";
+            lipsync: "lipsync";
+            translate_and_dub: "translate_and_dub";
+        }>;
+        seedSource: z.ZodEnum<{
+            output: "output";
+            "source-input": "source-input";
+        }>;
+    }, z.core.$strict>], "type">;
+}, z.core.$strict>;
+export declare const AcknowledgeStudioViewSchema: z.ZodObject<{
+    mountId: z.ZodUUID;
+    id: z.ZodUUID;
+    status: z.ZodEnum<{
+        applied: "applied";
+        blocked: "blocked";
+        failed: "failed";
+    }>;
+    reason: z.ZodOptional<z.ZodEnum<{
+        busy: "busy";
+        expired: "expired";
+        stale: "stale";
+        unavailable: "unavailable";
+    }>>;
+    context: z.ZodOptional<z.ZodObject<{
+        projectId: z.ZodNullable<z.ZodUUID>;
+        draftId: z.ZodNullable<z.ZodUUID>;
+        draftRevision: z.ZodNullable<z.ZodNumber>;
+        editToken: z.ZodOptional<z.ZodString>;
+        busy: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+//# sourceMappingURL=studio-view-contract.d.ts.map

package/dist/tools/studio-view-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"studio-view-contract.d.ts","sourceRoot":"","sources":["../../src/tools/studio-view-contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,uBAAuB;;;;;;kBASlC,CAAC;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAoBlC,CAAC;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgB3B,CAAC;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;kBAInC,CAAC;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAIxC,CAAC;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;kBAMtC,CAAC"}

package/dist/tools/studio-view-contract.js

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+const workflow = z.enum(['lipsync', 'image_to_video', 'translate_and_dub', 'edit_dialogue']);
+export const StudioViewContextSchema = z.strictObject({
+    projectId: z.uuid().nullable(),
+    draftId: z.uuid().nullable(),
+    draftRevision: z.number().int().nonnegative().nullable(),
+    editToken: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/)
+        .optional(),
+    busy: z.boolean(),
+});
+export const StudioViewCommandSchema = z.discriminatedUnion('type', [
+    z.strictObject({
+        type: z.literal('open-project'),
+        projectId: z.uuid(),
+        workflow: workflow.optional(),
+    }),
+    z.strictObject({ type: z.literal('refresh-project'), projectId: z.uuid() }),
+    z.strictObject({ type: z.literal('refresh-assets'), projectId: z.uuid() }),
+    z.strictObject({
+        type: z.literal('open-generation'),
+        projectId: z.uuid(),
+        generationId: z.uuid(),
+    }),
+    z.strictObject({
+        type: z.literal('continue-generation'),
+        projectId: z.uuid(),
+        generationId: z.uuid(),
+        workflow,
+        seedSource: z.enum(['source-input', 'output']),
+    }),
+]);
+export const StudioViewSchema = z.object({
+    id: z.uuid(),
+    revision: z.number().int().positive(),
+    context: StudioViewContextSchema,
+    updatedAt: z.number(),
+    action: z
+        .object({
+        id: z.uuid(),
+        requestRevision: z.number().int().positive(),
+        expectedContext: StudioViewContextSchema,
+        command: StudioViewCommandSchema,
+        expiresAt: z.number(),
+        status: z.enum(['pending', 'applied', 'blocked', 'failed']),
+        reason: z.enum(['busy', 'stale', 'expired', 'unavailable']).optional(),
+    })
+        .nullable(),
+});
+export const RegisterStudioViewSchema = z.strictObject({
+    mountId: z.uuid(),
+    claim: z.boolean().default(false),
+    context: StudioViewContextSchema,
+});
+export const RequestStudioViewActionSchema = z.strictObject({
+    id: z.uuid(),
+    expectedRevision: z.number().int().positive(),
+    command: StudioViewCommandSchema,
+});
+export const AcknowledgeStudioViewSchema = z.strictObject({
+    mountId: z.uuid(),
+    id: z.uuid(),
+    status: z.enum(['applied', 'blocked', 'failed']),
+    reason: z.enum(['busy', 'stale', 'expired', 'unavailable']).optional(),
+    context: StudioViewContextSchema.optional(),
+});

package/dist/tools/studio-view.d.ts

@@ -0,0 +1,6 @@
+import type { HttpClient } from '../http-client.js';
+import type { ParsedOperation } from '../openapi/types.js';
+import type { McpToolDefinition } from './generator.js';
+export declare function supportsStudioViews(operations: ParsedOperation[]): boolean;
+export declare function createStudioViewTools(operations: ParsedOperation[], http: HttpClient): McpToolDefinition[];
+//# sourceMappingURL=studio-view.d.ts.map

package/dist/tools/studio-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"studio-view.d.ts","sourceRoot":"","sources":["../../src/tools/studio-view.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AASxD,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,eAAe,EAAE,WAWhE;AACD,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,eAAe,EAAE,EAC7B,IAAI,EAAE,UAAU,GACf,iBAAiB,EAAE,CAsIrB"}

package/dist/tools/studio-view.js

@@ -0,0 +1,126 @@
+import { z } from 'zod';
+import { AcknowledgeStudioViewSchema, RegisterStudioViewSchema, RequestStudioViewActionSchema, StudioViewCommandSchema, StudioViewSchema, } from './studio-view-contract.js';
+export function supportsStudioViews(operations) {
+    return [
+        ['StudioViewsController_get', 'get'],
+        ['StudioViewsController_register', 'put'],
+        ['StudioViewsController_request', 'post'],
+        ['StudioViewsController_acknowledge', 'post'],
+    ].every(([id, method]) => operations.some((op) => op.operationId === id && op.method === method && op.studioViewVersion === 1));
+}
+export function createStudioViewTools(operations, http) {
+    if (!supportsStudioViews(operations))
+        return [];
+    const viewId = z.uuid();
+    const instructions = ' First studio-views_get for the exact published viewId, use its expectedRevision and a fresh UUID id; retry an uncertain handoff with the SAME id/body. Do not replace unresolved actions, guess a widget, or overwrite stale edits. On "Studio context is stale", studio-views_get again and retry once with its expectedRevision and a fresh id. On STUDIO_VIEW_NOT_OPEN, Studio is not open in this chat: tell the user to open Studio, then studio-views_get again; do not keep retrying. This never repeats backend creation or paid work. Check the action receipt through studio-views_get: only applied confirms UI display; pending/blocked/failed do not. Draft selection/settings edits use studio-drafts_get and studio-drafts_update.';
+    const actions = {
+        'open-project': {
+            name: 'studio-views_open-project',
+            title: 'Open a project in Studio',
+            description: 'Open an existing project in the mounted Studio, optionally selecting its workflow. Can replace the active editor state, archiving the prior draft. Does not create a project or generate media.',
+        },
+        'refresh-project': {
+            name: 'studio-views_refresh-project',
+            title: 'Refresh Studio project details',
+            description: 'Refresh an existing project in the mounted Studio after its backend details change, such as a rename. Does not rename or create the project.',
+        },
+        'refresh-assets': {
+            name: 'studio-views_refresh-assets',
+            title: 'Refresh Studio media',
+            description: 'Refresh an existing project’s media in the mounted Studio after an upload or asset registration succeeds. Does not upload, register, delete or select media.',
+        },
+        'open-generation': {
+            name: 'studio-views_show-generation',
+            title: 'Show an existing Studio generation',
+            description: 'Display an already accepted generation or its result in the mounted Studio, opening its project if needed. Replaces the active editor state and archives the prior draft. Does not submit or retry generation.',
+        },
+        'continue-generation': {
+            name: 'studio-views_continue-generation',
+            title: 'Continue an existing Studio generation',
+            description: 'For an explicit user request, stage an existing generation’s source input or output as a new editable draft in the selected workflow. Replaces the active draft and archives its prior state; output continuation may register existing output as Sync media. Does not generate or synthesize media.',
+        },
+    };
+    const actionTools = StudioViewCommandSchema.options.map((command) => {
+        const { type: discriminator, ...fields } = command.shape;
+        const type = discriminator.value;
+        const schema = RequestStudioViewActionSchema.omit({ command: true }).extend(fields);
+        return {
+            ...actions[type],
+            description: actions[type].description + instructions,
+            schema,
+            bodySchema: schema.transform(({ id, expectedRevision, ...commandFields }) => ({
+                id,
+                expectedRevision,
+                command: command.parse({ ...commandFields, type }),
+            })),
+            suffix: '/actions',
+            method: 'post',
+            appOnly: false,
+            destructive: type !== 'refresh-project' && type !== 'refresh-assets',
+        };
+    });
+    const tools = [
+        [
+            'studio-views_get',
+            'Read mounted Studio view',
+            z.object({}),
+            '',
+            'get',
+            false,
+            'Read the exact viewId published by the mounted Studio, including its current revision and last action receipt. No view list or inferred latest widget. pending means not displayed; blocked needs the UI action/recovery completed; failed was not confirmed; applied confirms that action was displayed. An unavailable view must be reopened.',
+        ],
+        [
+            'studio-views_register',
+            'Register mounted Studio view',
+            RegisterStudioViewSchema,
+            '',
+            'put',
+            true,
+            'Studio-only view ownership/context registration. No provider work.',
+        ],
+        [
+            'studio-views_ack',
+            'Acknowledge displayed Studio action',
+            AcknowledgeStudioViewSchema,
+            '/acknowledgement',
+            'post',
+            true,
+            'Studio-only application receipt. No provider work.',
+        ],
+    ];
+    return [
+        ...tools.map(([name, title, schema, suffix, method, appOnly, description]) => ({
+            name,
+            title,
+            schema,
+            bodySchema: schema,
+            suffix,
+            method,
+            appOnly,
+            description,
+            destructive: false,
+        })),
+        ...actionTools,
+    ].map(({ name, title, schema, bodySchema, suffix, method, appOnly, description, destructive, }) => ({
+        name,
+        title,
+        description,
+        inputSchema: { viewId, ...schema.shape },
+        outputSchema: StudioViewSchema.shape,
+        annotations: {
+            readOnlyHint: method === 'get',
+            destructiveHint: destructive,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+        ...(appOnly ? { meta: { ui: { visibility: ['app'] } } } : {}),
+        handler: async (args, context) => {
+            const { viewId: rawId, ...body } = args;
+            const id = viewId.parse(rawId);
+            return StudioViewSchema.refine((view) => view.id === id).parse(await http.request(method, `/v2/studio-views/${id}${suffix}`, {
+                body: method === 'get' ? undefined : bodySchema.parse(body),
+                signal: context?.signal,
+            }));
+        },
+    }));
+}