@sync.so/mcp-server 0.1.4 → 0.2.0

package/package.json

@@ -1,29 +1,35 @@
 {
   "name": "@sync.so/mcp-server",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "MCP server for the Sync API — give AI agents the ability to create lipsync videos, manage assets, and more",
   "keywords": [
+    "ai",
+    "lipsync",
     "mcp",
+    "model-context-protocol",
     "sync",
-    "lipsync",
-    "ai",
-    "video",
-    "model-context-protocol"
+    "video"
   ],
+  "homepage": "https://sync.so/docs",
+  "bugs": {
+    "url": "https://github.com/synchronicity-labs/mcp-server/issues"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/synchronicity-labs/mcp-server.git"
   },
-  "homepage": "https://sync.so/docs",
-  "bugs": {
-    "url": "https://github.com/synchronicity-labs/mcp-server/issues"
-  },
-  "type": "module",
   "bin": {
     "mcp-server": "./dist/cli.js",
     "sync-mcp": "./dist/cli.js"
   },
+  "files": [
+    "dist",
+    "deploy/generation-status",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -33,34 +39,74 @@
       "types": "./dist/index.d.ts"
     }
   },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "engines": {
-    "node": ">=18.0.0"
-  },
   "scripts": {
-    "build": "tsc -b && chmod +x dist/cli.js",
+    "build": "tsc -b tsconfig.build.json && chmod +x dist/cli.js",
+    "package:chatgpt": "node scripts/package-chatgpt.mjs",
+    "verify:chatgpt-package": "node scripts/verify-chatgpt-package.mjs",
+    "package:plugin": "node scripts/package-plugin.mjs",
+    "verify:plugin": "node scripts/verify-plugin-package.mjs",
+    "skills:update": "node scripts/update-plugin-skills.mjs",
     "clean": "rm -rf dist .cache",
-    "dev": "tsc -b --watch",
-    "lint": "biome check ./src",
-    "lint:fix": "biome check --fix ./src",
-    "format": "biome format --write ./src",
+    "dev": "tsc -b tsconfig.build.json --watch",
+    "lint": "oxlint src scripts && oxfmt --check",
+    "knip": "knip && knip --cycles",
+    "lint:fix": "oxlint --fix src scripts && oxfmt",
+    "format": "oxfmt",
     "test": "vitest run",
+    "test:memory": "node --expose-gc --max-old-space-size=512 scripts/verify-session-memory.mjs",
+    "test:memory:http": "node --expose-gc --max-old-space-size=512 scripts/verify-http-memory.mjs",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit --emitDeclarationOnly false",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "pnpm run clean && pnpm run build",
+    "test:browser": "vitest run --config vitest.browser.config.ts",
+    "monitor:mcp": "node scripts/check-mcp.mjs",
+    "prepare": "husky",
+    "test:scripts": "node --test scripts/*.test.mjs",
+    "capture:wire": "node scripts/capture-wire.mjs"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.27.1",
-    "zod": "^4.1.13"
+    "@modelcontextprotocol/client": "2.4.0",
+    "@modelcontextprotocol/core": "2.4.0",
+    "@modelcontextprotocol/node": "2.1.2",
+    "@modelcontextprotocol/server": "2.4.0",
+    "@modelcontextprotocol/server-legacy": "2.4.0",
+    "cors": "^2.8.6",
+    "express": "^5.3.0",
+    "express-rate-limit": "^8.7.2",
+    "ipaddr.js": "^2.5.0",
+    "undici": "^8.12.2",
+    "zod": "^4.6.7"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.7",
-    "@types/node": "^22.5.0",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.12"
-  }
+    "@playwright/test": "1.64.1",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@types/node": "^26.6.0",
+    "husky": "^9.1.7",
+    "knip": "6.44.0",
+    "lint-staged": "^17.6.0",
+    "oxfmt": "0.75.0",
+    "oxlint": "1.90.0",
+    "oxlint-tsgolint": "7.0.2005",
+    "typescript": "^7.0.2",
+    "vitest": "5.0.5"
+  },
+  "lint-staged": {
+    "package.json": "oxfmt --check --no-error-on-unmatched-pattern",
+    "*.{js,ts,mjs,cjs,mts,cts}": [
+      "oxlint --no-error-on-unmatched-pattern",
+      "oxfmt --check --no-error-on-unmatched-pattern"
+    ]
+  },
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "version": ">=26.0.0",
+      "onFail": "error"
+    }
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "packageManager": "pnpm@12.14.0"
 }

package/dist/openapi/parser.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=parser.test.d.ts.map

package/dist/openapi/parser.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parser.test.d.ts","sourceRoot":"","sources":["../../src/openapi/parser.test.ts"],"names":[],"mappings":""}

package/dist/openapi/parser.test.js

@@ -1,188 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { parseSpec, resolveRef, resolveSchemaRefs } from './parser.js';
-const MINIMAL_SPEC = {
-    openapi: '3.1.0',
-    paths: {
-        '/v2/generate': {
-            post: {
-                operationId: 'GenerateController_createGeneration',
-                summary: 'Create a generation',
-                tags: ['Generate'],
-                parameters: [],
-                requestBody: {
-                    content: {
-                        'application/json': {
-                            schema: {
-                                type: 'object',
-                                properties: {
-                                    model: { type: 'string' },
-                                    input: { type: 'array', items: { type: 'object' } },
-                                },
-                                required: ['model', 'input'],
-                            },
-                        },
-                    },
-                },
-            },
-        },
-        '/v2/generate/{id}': {
-            get: {
-                operationId: 'GenerateController_getGeneration',
-                summary: 'Get a generation by ID',
-                tags: ['Generate'],
-                parameters: [
-                    {
-                        name: 'id',
-                        in: 'path',
-                        required: true,
-                        schema: { type: 'string' },
-                    },
-                ],
-            },
-        },
-        '/v2/internal/something': {
-            get: {
-                operationId: 'InternalController_doSomething',
-                summary: 'Internal endpoint',
-                tags: ['internal'],
-                parameters: [],
-            },
-        },
-    },
-};
-describe('parseSpec', () => {
-    it('parses operations from OpenAPI spec', () => {
-        const operations = parseSpec(MINIMAL_SPEC);
-        expect(operations).toHaveLength(2);
-    });
-    it('extracts operation details correctly', () => {
-        const operations = parseSpec(MINIMAL_SPEC);
-        const createOp = operations.find((op) => op.operationId === 'GenerateController_createGeneration');
-        expect(createOp).toBeDefined();
-        expect(createOp?.method).toBe('post');
-        expect(createOp?.path).toBe('/v2/generate');
-        expect(createOp?.summary).toBe('Create a generation');
-        expect(createOp?.requestBody).toBeDefined();
-    });
-    it('parses path parameters', () => {
-        const operations = parseSpec(MINIMAL_SPEC);
-        const getOp = operations.find((op) => op.operationId === 'GenerateController_getGeneration');
-        expect(getOp).toBeDefined();
-        expect(getOp?.parameters).toHaveLength(1);
-        expect(getOp?.parameters[0]?.name).toBe('id');
-        expect(getOp?.parameters[0]?.in).toBe('path');
-        expect(getOp?.parameters[0]?.required).toBe(true);
-    });
-    it('filters out internal-tagged endpoints', () => {
-        const operations = parseSpec(MINIMAL_SPEC);
-        const internalOp = operations.find((op) => op.operationId === 'InternalController_doSomething');
-        expect(internalOp).toBeUndefined();
-    });
-    it('skips operations without operationId', () => {
-        const spec = {
-            openapi: '3.1.0',
-            paths: {
-                '/v2/test': {
-                    get: {
-                        summary: 'No operation ID',
-                        tags: ['Test'],
-                    },
-                },
-            },
-        };
-        const operations = parseSpec(spec);
-        expect(operations).toHaveLength(0);
-    });
-    it('detects multipart endpoints', () => {
-        const spec = {
-            openapi: '3.1.0',
-            paths: {
-                '/v2/upload': {
-                    post: {
-                        operationId: 'UploadController_upload',
-                        summary: 'Upload a file',
-                        tags: ['Upload'],
-                        parameters: [],
-                        requestBody: {
-                            content: {
-                                'multipart/form-data': {
-                                    schema: { type: 'object' },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        };
-        const operations = parseSpec(spec);
-        expect(operations[0]?.isMultipart).toBe(true);
-    });
-});
-describe('resolveRef', () => {
-    it('resolves $ref to component schemas', () => {
-        const spec = {
-            openapi: '3.1.0',
-            paths: {},
-            components: {
-                schemas: {
-                    MyModel: { type: 'object', properties: { name: { type: 'string' } } },
-                },
-            },
-        };
-        const resolved = resolveRef(spec, '#/components/schemas/MyModel');
-        expect(resolved).toEqual({
-            type: 'object',
-            properties: { name: { type: 'string' } },
-        });
-    });
-});
-describe('resolveSchemaRefs', () => {
-    const spec = {
-        openapi: '3.1.0',
-        paths: {},
-        components: {
-            schemas: {
-                Status: { type: 'string', enum: ['pending', 'completed'] },
-            },
-        },
-    };
-    it('resolves $ref in schema', () => {
-        const schema = { $ref: '#/components/schemas/Status' };
-        const resolved = resolveSchemaRefs(schema, spec);
-        expect(resolved).toEqual({
-            type: 'string',
-            enum: ['pending', 'completed'],
-        });
-    });
-    it('passes through schemas without $ref', () => {
-        const schema = { type: 'string' };
-        const resolved = resolveSchemaRefs(schema, spec);
-        expect(resolved).toEqual({ type: 'string' });
-    });
-    it('resolves nested $ref in properties', () => {
-        const schema = {
-            type: 'object',
-            properties: {
-                status: { $ref: '#/components/schemas/Status' },
-            },
-        };
-        const resolved = resolveSchemaRefs(schema, spec);
-        expect(resolved).toEqual({
-            type: 'object',
-            properties: {
-                status: { type: 'string', enum: ['pending', 'completed'] },
-            },
-        });
-    });
-    it('resolves $ref in additionalProperties', () => {
-        const schema = {
-            type: 'object',
-            additionalProperties: { $ref: '#/components/schemas/Status' },
-        };
-        const resolved = resolveSchemaRefs(schema, spec);
-        expect(resolved).toEqual({
-            type: 'object',
-            additionalProperties: { type: 'string', enum: ['pending', 'completed'] },
-        });
-    });
-});

package/dist/tools/generator.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=generator.test.d.ts.map

package/dist/tools/generator.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generator.test.d.ts","sourceRoot":"","sources":["../../src/tools/generator.test.ts"],"names":[],"mappings":""}

package/dist/tools/generator.test.js

@@ -1,178 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { generateTools, operationIdToToolName } from './generator.js';
-describe('operationIdToToolName', () => {
-    it('converts controller operation IDs to tool names', () => {
-        expect(operationIdToToolName('GenerateController_createGeneration')).toBe('generate_create-generation');
-        expect(operationIdToToolName('AssetsController_getAll')).toBe('assets_get-all');
-        expect(operationIdToToolName('ModelsController_getPublic')).toBe('models_get-public');
-    });
-    it('kebab-cases multi-word controller names', () => {
-        expect(operationIdToToolName('DeviceAuthController_start')).toBe('device-auth_start');
-        expect(operationIdToToolName('AssetMetadataController_getAll')).toBe('asset-metadata_get-all');
-    });
-    it('handles single-part operation IDs', () => {
-        expect(operationIdToToolName('createSomething')).toBe('create-something');
-    });
-});
-describe('generateTools', () => {
-    const mockHttpClient = {
-        request: vi.fn().mockResolvedValue({ id: 'gen-123' }),
-    };
-    const operations = [
-        {
-            operationId: 'GenerateController_createGeneration',
-            method: 'post',
-            path: '/v2/generate',
-            summary: 'Create a generation',
-            tags: ['Generate'],
-            parameters: [],
-            requestBody: {
-                schema: {
-                    type: 'object',
-                    properties: {
-                        model: { type: 'string' },
-                    },
-                    required: ['model'],
-                },
-                contentType: 'application/json',
-            },
-            isMultipart: false,
-        },
-        {
-            operationId: 'GenerateController_getGeneration',
-            method: 'get',
-            path: '/v2/generate/{id}',
-            summary: 'Get a generation by ID',
-            tags: ['Generate'],
-            parameters: [
-                {
-                    name: 'id',
-                    in: 'path',
-                    required: true,
-                    schema: { type: 'string' },
-                },
-            ],
-            isMultipart: false,
-        },
-    ];
-    it('generates tools from operations', () => {
-        const tools = generateTools(operations, mockHttpClient);
-        expect(tools).toHaveLength(2);
-        expect(tools[0]?.name).toBe('generate_create-generation');
-        expect(tools[1]?.name).toBe('generate_get-generation');
-    });
-    it('uses overrides for known tools', () => {
-        const tools = generateTools(operations, mockHttpClient);
-        expect(tools[0]?.description).toContain('lipsync video');
-    });
-    it('handler calls httpClient with correct params', async () => {
-        const tools = generateTools(operations, mockHttpClient);
-        await tools[0]?.handler({ model: 'sync-1.9.0-beta' });
-        expect(mockHttpClient.request).toHaveBeenCalledWith('post', '/v2/generate', {
-            query: undefined,
-            body: { model: 'sync-1.9.0-beta' },
-        });
-    });
-    it('handler substitutes path parameters', async () => {
-        const tools = generateTools(operations, mockHttpClient);
-        await tools[1]?.handler({ id: 'gen-456' });
-        expect(mockHttpClient.request).toHaveBeenCalledWith('get', '/v2/generate/gen-456', {
-            query: undefined,
-            body: undefined,
-        });
-    });
-    it('handler builds query parameters', async () => {
-        const opWithQuery = [
-            {
-                operationId: 'AssetsController_getAll',
-                method: 'get',
-                path: '/v2/assets',
-                summary: 'List assets',
-                tags: ['Assets'],
-                parameters: [
-                    {
-                        name: 'limit',
-                        in: 'query',
-                        required: false,
-                        schema: { type: 'number' },
-                    },
-                ],
-                isMultipart: false,
-            },
-        ];
-        const tools = generateTools(opWithQuery, mockHttpClient);
-        await tools[0]?.handler({ limit: 10 });
-        expect(mockHttpClient.request).toHaveBeenCalledWith('get', '/v2/assets', {
-            query: { limit: '10' },
-            body: undefined,
-        });
-    });
-    it('handles allOf composed body schemas', async () => {
-        const opWithAllOf = [
-            {
-                operationId: 'TestController_create',
-                method: 'post',
-                path: '/v2/test',
-                summary: 'Test allOf',
-                tags: ['Test'],
-                parameters: [],
-                requestBody: {
-                    schema: {
-                        allOf: [
-                            {
-                                type: 'object',
-                                properties: { name: { type: 'string' } },
-                                required: ['name'],
-                            },
-                            {
-                                type: 'object',
-                                properties: { age: { type: 'number' } },
-                            },
-                        ],
-                    },
-                    contentType: 'application/json',
-                },
-                isMultipart: false,
-            },
-        ];
-        const tools = generateTools(opWithAllOf, mockHttpClient);
-        await tools[0]?.handler({ name: 'test', age: 25 });
-        expect(mockHttpClient.request).toHaveBeenCalledWith('post', '/v2/test', {
-            query: undefined,
-            body: { name: 'test', age: 25 },
-        });
-    });
-    it('handles schema with both properties and allOf', async () => {
-        const opWithBoth = [
-            {
-                operationId: 'TestController_mixed',
-                method: 'post',
-                path: '/v2/mixed',
-                summary: 'Test mixed',
-                tags: ['Test'],
-                parameters: [],
-                requestBody: {
-                    schema: {
-                        type: 'object',
-                        properties: { base: { type: 'string' } },
-                        required: ['base'],
-                        allOf: [
-                            {
-                                type: 'object',
-                                properties: { extra: { type: 'number' } },
-                            },
-                        ],
-                    },
-                    contentType: 'application/json',
-                },
-                isMultipart: false,
-            },
-        ];
-        const tools = generateTools(opWithBoth, mockHttpClient);
-        await tools[0]?.handler({ base: 'hello', extra: 42 });
-        expect(mockHttpClient.request).toHaveBeenCalledWith('post', '/v2/mixed', {
-            query: undefined,
-            body: { base: 'hello', extra: 42 },
-        });
-    });
-});