@remix-gg/mcp 0.4.3

package/dist/core/tools.test.js

@@ -0,0 +1,825 @@
+import { beforeEach, describe, expect, it, mock } from 'bun:test';
+const mockReadFile = mock(async (..._args) => '');
+const mockStat = mock(async () => ({ size: 1024 }));
+const mockPost = mock(async (..._args) => ({
+    data: undefined,
+    error: undefined,
+    response: new Response(null, { status: 200 }),
+}));
+const mockGet = mock(async (..._args) => ({
+    data: undefined,
+    error: undefined,
+    response: new Response(null, { status: 200 }),
+}));
+const mockDelete = mock(async (..._args) => ({
+    data: undefined,
+    error: undefined,
+    response: new Response(null, { status: 200 }),
+}));
+const mockCreateServerApiClient = mock((..._args) => ({
+    DELETE: mockDelete,
+    GET: mockGet,
+    POST: mockPost,
+}));
+mock.module('node:fs/promises', () => ({
+    readFile: mockReadFile,
+    stat: mockStat,
+}));
+mock.module('./api-client.js', () => ({
+    createServerApiClient: mockCreateServerApiClient,
+}));
+const { createShopItem, createGame, deleteShopItem, updateGame, uploadVersion, generateImage, generateSpriteSheet, listShopItems, updateShopItem, uploadGameAsset, validateGame, } = await import('./tools/index.js');
+describe('core tools', () => {
+    beforeEach(() => {
+        mockReadFile.mockReset();
+        mockStat.mockReset();
+        mockGet.mockReset();
+        mockDelete.mockReset();
+        mockPost.mockReset();
+        mockCreateServerApiClient.mockClear();
+        mockReadFile.mockResolvedValue('');
+        mockStat.mockResolvedValue({ size: 1024 });
+        mockGet.mockResolvedValue({
+            data: undefined,
+            error: undefined,
+            response: new Response(null, { status: 200 }),
+        });
+        mockDelete.mockResolvedValue({
+            data: undefined,
+            error: undefined,
+            response: new Response(null, { status: 200 }),
+        });
+        mockPost.mockResolvedValue({
+            data: undefined,
+            error: undefined,
+            response: new Response(null, { status: 200 }),
+        });
+        mockCreateServerApiClient.mockReturnValue({
+            DELETE: mockDelete,
+            GET: mockGet,
+            POST: mockPost,
+        });
+    });
+    describe('createGame()', () => {
+        it('creates a game via the API client and maps the response', async () => {
+            mockPost.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    data: {
+                        game: {
+                            id: 'game-1',
+                            name: 'Test Game',
+                            createdAt: '2026-03-03T00:00:00.000Z',
+                            version: {
+                                id: 'version-1',
+                                createdAt: '2026-03-03T00:00:00.000Z',
+                            },
+                        },
+                    },
+                },
+                error: undefined,
+                response: new Response(null, { status: 201 }),
+            });
+            const result = await createGame('Test Game', {
+                apiKey: 'key',
+                apiBaseUrl: 'https://api.remix.gg',
+            });
+            expect(mockCreateServerApiClient).toHaveBeenCalledWith({
+                apiKey: 'key',
+                apiBaseUrl: 'https://api.remix.gg',
+            });
+            expect(mockPost).toHaveBeenCalledWith('/v1/games', {
+                body: { name: 'Test Game' },
+            });
+            expect(result).toEqual({
+                gameId: 'game-1',
+                versionId: 'version-1',
+                name: 'Test Game',
+                createdAt: '2026-03-03T00:00:00.000Z',
+            });
+        });
+        it('throws a normalized API error when the request fails', async () => {
+            mockPost.mockResolvedValueOnce({
+                data: undefined,
+                error: { error: { message: 'Forbidden' } },
+                response: new Response(null, { status: 403, statusText: 'Forbidden' }),
+            });
+            await expect(createGame('Test Game')).rejects.toThrow('Remix API error (403): Forbidden');
+        });
+    });
+    describe('updateGame()', () => {
+        it('updates a game and maps the response', async () => {
+            mockPost.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    data: {
+                        game: {
+                            id: 'game-1',
+                            name: 'Updated Name',
+                            isMultiplayer: true,
+                        },
+                    },
+                },
+                error: undefined,
+                response: new Response(null, { status: 200 }),
+            });
+            const result = await updateGame('game-1', {
+                name: 'Updated Name',
+                isMultiplayer: true,
+            });
+            expect(mockPost).toHaveBeenCalledWith('/v1/games/{gameId}', {
+                params: { path: { gameId: 'game-1' } },
+                body: { name: 'Updated Name', isMultiplayer: true },
+            });
+            expect(result).toEqual({
+                gameId: 'game-1',
+                name: 'Updated Name',
+                isMultiplayer: true,
+            });
+        });
+        it('forwards only provided fields', async () => {
+            mockPost.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    data: {
+                        game: {
+                            id: 'game-1',
+                            name: 'Existing Name',
+                            isMultiplayer: false,
+                        },
+                    },
+                },
+                error: undefined,
+                response: new Response(null, { status: 200 }),
+            });
+            await updateGame('game-1', { isMultiplayer: false });
+            const call = mockPost.mock.calls[0];
+            expect(call[1].body).toEqual({ isMultiplayer: false });
+            expect(call[1].body).not.toHaveProperty('name');
+        });
+    });
+    describe('uploadVersion()', () => {
+        it('reads the file and uploads code to the expected endpoint', async () => {
+            mockReadFile.mockResolvedValueOnce('<html>game</html>');
+            mockPost.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    data: {
+                        success: true,
+                        gameId: 'game-1',
+                        versionId: 'version-1',
+                    },
+                },
+                error: undefined,
+                response: new Response(null, { status: 200 }),
+            });
+            const result = await uploadVersion('game-1', 'version-1', '/tmp/game.html');
+            expect(mockReadFile).toHaveBeenCalledWith('/tmp/game.html', 'utf-8');
+            expect(mockPost).toHaveBeenCalledWith('/v1/games/{gameId}/versions/{versionId}/code', {
+                params: { path: { gameId: 'game-1', versionId: 'version-1' } },
+                body: { code: '<html>game</html>' },
+            });
+            expect(result).toEqual({
+                gameId: 'game-1',
+                versionId: 'version-1',
+                threadId: undefined,
+            });
+        });
+    });
+    describe('validateGame()', () => {
+        it('returns no issues for valid Remix HTML', async () => {
+            mockReadFile.mockResolvedValueOnce(`<!DOCTYPE html>
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <script src="https://cdn.jsdelivr.net/npm/@remix-gg/sdk@latest/dist/index.min.js"></script>
+  </head>
+  <body>
+    <script>
+      window.RemixSDK?.onToggleMute(() => {})
+      window.RemixSDK?.onPlayAgain(() => {})
+      window.RemixSDK?.singlePlayer.actions.gameOver({ score: 10 })
+    </script>
+  </body>
+</html>`);
+            await expect(validateGame('/tmp/game.html')).resolves.toEqual({
+                valid: true,
+                issues: [],
+            });
+        });
+        it('accepts multiplayer.actions.gameOver as valid', async () => {
+            mockReadFile.mockResolvedValueOnce(`<!DOCTYPE html>
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <script src="https://cdn.jsdelivr.net/npm/@remix-gg/sdk@latest/dist/index.min.js"></script>
+  </head>
+  <body>
+    <script>
+      window.RemixSDK?.onToggleMute(() => {})
+      window.RemixSDK?.onPlayAgain(() => {})
+      window.RemixSDK?.multiplayer.actions.gameOver({ scores: [] })
+    </script>
+  </body>
+</html>`);
+            await expect(validateGame('/tmp/game.html')).resolves.toEqual({
+                valid: true,
+                issues: [],
+            });
+        });
+        it('accepts a versioned Remix SDK script tag', async () => {
+            mockReadFile.mockResolvedValueOnce(`<!DOCTYPE html>
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <script src="https://cdn.jsdelivr.net/npm/@remix-gg/sdk@1.2.3/dist/index.min.js"></script>
+  </head>
+  <body>
+    <script>
+      window.RemixSDK?.onToggleMute(() => {})
+      window.RemixSDK?.onPlayAgain(() => {})
+      window.RemixSDK?.singlePlayer.actions.gameOver({ score: 10 })
+    </script>
+  </body>
+</html>`);
+            await expect(validateGame('/tmp/game.html')).resolves.toEqual({
+                valid: true,
+                issues: [],
+            });
+        });
+        it('rejects both singlePlayer and multiplayer gameOver in the same game', async () => {
+            mockReadFile.mockResolvedValueOnce(`<!DOCTYPE html>
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <script src="https://cdn.jsdelivr.net/npm/@remix-gg/sdk@latest/dist/index.min.js"></script>
+  </head>
+  <body>
+    <script>
+      window.RemixSDK?.onToggleMute(() => {})
+      window.RemixSDK?.onPlayAgain(() => {})
+      window.RemixSDK?.singlePlayer.actions.gameOver({ score: 10 })
+      window.RemixSDK?.multiplayer.actions.gameOver({ scores: [] })
+      window.RemixSDK?.multiplayer.actions.gameOver({ scores: [] })
+    </script>
+  </body>
+</html>`);
+            const result = await validateGame('/tmp/game.html');
+            expect(result.valid).toBe(false);
+            expect(result.issues).toContain('Both singlePlayer.actions.gameOver and multiplayer.actions.gameOver detected — use exactly one. Use singlePlayer for solo games, multiplayer for two-player games.');
+        });
+        it('reports legacy Farcade SDK usage with a migration-specific issue', async () => {
+            mockReadFile.mockResolvedValueOnce(`<!DOCTYPE html>
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <script src="https://cdn.jsdelivr.net/npm/@farcade/game-sdk@latest/dist/index.min.js"></script>
+  </head>
+  <body>
+    <script>
+      window.RemixSDK?.onToggleMute(() => {})
+      window.RemixSDK?.onPlayAgain(() => {})
+      window.RemixSDK?.singlePlayer.actions.gameOver({ score: 10 })
+    </script>
+  </body>
+</html>`);
+            const result = await validateGame('/tmp/game.html');
+            expect(result.valid).toBe(false);
+            expect(result.issues).toContain('Legacy @farcade/game-sdk script detected — replace it with <script src="https://cdn.jsdelivr.net/npm/@remix-gg/sdk@latest/dist/index.min.js"></script>');
+            expect(result.issues).not.toContain('Missing RemixSDK script tag in <head> — add: <script src="https://cdn.jsdelivr.net/npm/@remix-gg/sdk@latest/dist/index.min.js"></script>');
+        });
+        it('reports missing required integrations and unsafe patterns', async () => {
+            mockReadFile.mockResolvedValueOnce('<html><body><button onclick="play()"></button></body></html>');
+            const result = await validateGame('/tmp/game.html');
+            expect(result.valid).toBe(false);
+            expect(result.issues).toContain('Missing <!DOCTYPE html> declaration');
+            expect(result.issues).toContain('Missing viewport meta tag — needed for mobile play');
+            expect(result.issues).toContain('Missing RemixSDK script tag in <head> — add: <script src="https://cdn.jsdelivr.net/npm/@remix-gg/sdk@latest/dist/index.min.js"></script>');
+            expect(result.issues).toContain('Missing gameOver call — use singlePlayer.actions.gameOver({ score }) for solo games or multiplayer.actions.gameOver({ scores }) for two-player games');
+            expect(result.issues).toContain('Missing onToggleMute(callback) call — must register a callback to handle mute/unmute');
+            expect(result.issues).toContain('Missing onPlayAgain(callback) call — must register a callback to restart the game');
+            expect(result.issues).toContain('Inline event handlers detected — use addEventListener instead');
+        });
+    });
+    describe('generateImage()', () => {
+        it('generates an image, uploads it as an asset, and returns the hosted URL', async () => {
+            mockPost
+                .mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    data: {
+                        image: {
+                            data: Buffer.from('png-bytes').toString('base64'),
+                            contentType: 'image/png',
+                        },
+                        prompt: 'hero sprite',
+                    },
+                },
+                error: undefined,
+                response: new Response(null, { status: 200 }),
+            })
+                .mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    data: {
+                        gameId: 'game-1',
+                        asset: { url: 'https://cdn.remix.gg/hero-sprite.png' },
+                    },
+                },
+                error: undefined,
+                response: new Response(null, { status: 200 }),
+            });
+            const result = await generateImage('game-1', 'Hero Sprite');
+            expect(mockPost).toHaveBeenNthCalledWith(1, '/v1/games/{gameId}/images/generate', {
+                params: { path: { gameId: 'game-1' } },
+                body: { prompt: 'Hero Sprite' },
+            });
+            const uploadCall = mockPost.mock.calls[1];
+            expect(uploadCall[0]).toBe('/v1/games/{gameId}/assets');
+            expect(uploadCall[1].params).toEqual({ path: { gameId: 'game-1' } });
+            expect(uploadCall[1].body).toBeInstanceOf(FormData);
+            expect(result).toEqual({
+                url: 'https://cdn.remix.gg/hero-sprite.png',
+                fileName: 'hero-sprite.png',
+                prompt: 'Hero Sprite',
+            });
+        });
+    });
+    describe('generateSpriteSheet()', () => {
+        it('passes prompt options through and maps the sprite response', async () => {
+            mockPost.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    data: {
+                        spriteUrl: 'https://cdn.remix.gg/sprite.png',
+                        transparentSpriteUrl: 'https://cdn.remix.gg/sprite-transparent.png',
+                        promptOriginal: 'knight attack',
+                        promptRewritten: 'pixel knight attack animation',
+                        metadata: {
+                            gridSize: 6,
+                            gridDimensions: '6x6',
+                        },
+                        warnings: ['large sprite sheet'],
+                    },
+                },
+                error: undefined,
+                response: new Response(null, { status: 200 }),
+            });
+            const result = await generateSpriteSheet('game-1', 'knight attack', 6, 'https://example.com/reference.png');
+            expect(mockPost).toHaveBeenCalledWith('/v1/games/{gameId}/sprites/generate', {
+                params: { path: { gameId: 'game-1' } },
+                body: {
+                    prompt: 'knight attack',
+                    gridSize: 6,
+                    imageUrl: 'https://example.com/reference.png',
+                },
+            });
+            expect(result).toEqual({
+                spriteUrl: 'https://cdn.remix.gg/sprite.png',
+                transparentSpriteUrl: 'https://cdn.remix.gg/sprite-transparent.png',
+                promptOriginal: 'knight attack',
+                promptRewritten: 'pixel knight attack animation',
+                metadata: {
+                    gridSize: 6,
+                    gridDimensions: '6x6',
+                },
+                warnings: ['large sprite sheet'],
+            });
+        });
+    });
+    describe('uploadGameAsset()', () => {
+        it('rejects unsupported file types before calling the API', async () => {
+            await expect(uploadGameAsset('game-1', '/tmp/asset.txt')).rejects.toThrow('Unsupported file type ".txt"');
+            expect(mockStat).not.toHaveBeenCalled();
+            expect(mockPost).not.toHaveBeenCalled();
+        });
+        it('rejects oversized files before reading them', async () => {
+            mockStat.mockResolvedValueOnce({ size: 6 * 1024 * 1024 });
+            await expect(uploadGameAsset('game-1', '/tmp/asset.png')).rejects.toThrow('File is too large (6.0 MB). Maximum allowed size is 5 MB.');
+            expect(mockReadFile).not.toHaveBeenCalled();
+            expect(mockPost).not.toHaveBeenCalled();
+        });
+        it('uploads supported files with form data and returns the raw response', async () => {
+            mockReadFile.mockResolvedValueOnce(Buffer.from('asset-bytes'));
+            mockPost.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    data: {
+                        gameId: 'game-1',
+                        asset: { id: 'asset-1', url: 'https://cdn.remix.gg/asset.png' },
+                    },
+                },
+                error: undefined,
+                response: new Response(null, { status: 200 }),
+            });
+            const result = await uploadGameAsset('game-1', '/tmp/asset.png', 'hero-asset');
+            expect(mockStat).toHaveBeenCalledWith('/tmp/asset.png');
+            expect(mockReadFile).toHaveBeenCalledWith('/tmp/asset.png');
+            const uploadCall = mockPost.mock.calls[0];
+            expect(uploadCall[0]).toBe('/v1/games/{gameId}/assets');
+            expect(uploadCall[1].params).toEqual({ path: { gameId: 'game-1' } });
+            expect(uploadCall[1].body).toBeInstanceOf(FormData);
+            expect(result).toEqual({
+                fileName: 'asset.png',
+                gameId: 'game-1',
+                response: {
+                    success: true,
+                    data: {
+                        gameId: 'game-1',
+                        asset: { id: 'asset-1', url: 'https://cdn.remix.gg/asset.png' },
+                    },
+                },
+            });
+        });
+    });
+    describe('createShopItem()', () => {
+        it('creates a shop item and normalizes numeric fields', async () => {
+            mockPost.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    data: {
+                        item: {
+                            id: 'item-1',
+                            gameId: 'game-1',
+                            name: 'Extra Life',
+                            slug: 'extra-life',
+                            status: 'ACTIVE',
+                            itemType: 'CONSUMABLE',
+                            bitsCost: '50',
+                            description: 'Spend one to restore a life.',
+                            iconUrl: 'https://cdn.remix.gg/extra-life.png',
+                            tier: null,
+                            createdAt: '2026-03-03T00:00:00.000Z',
+                            updatedAt: '2026-03-03T00:00:00.000Z',
+                        },
+                    },
+                },
+                error: undefined,
+                response: new Response(null, { status: 201 }),
+            });
+            const result = await createShopItem({
+                gameId: 'game-1',
+                name: 'Extra Life',
+                slug: 'extra-life',
+                itemType: 'CONSUMABLE',
+                bitsCost: 50,
+                description: 'Spend one to restore a life.',
+                iconUrl: 'https://cdn.remix.gg/extra-life.png',
+            });
+            expect(mockPost).toHaveBeenCalledWith('/v1/games/{gameId}/items', {
+                params: {
+                    path: {
+                        gameId: 'game-1',
+                    },
+                },
+                body: {
+                    name: 'Extra Life',
+                    slug: 'extra-life',
+                    itemType: 'CONSUMABLE',
+                    bitsCost: 50,
+                    description: 'Spend one to restore a life.',
+                    iconUrl: 'https://cdn.remix.gg/extra-life.png',
+                },
+            });
+            expect(result).toEqual({
+                id: 'item-1',
+                gameId: 'game-1',
+                name: 'Extra Life',
+                slug: 'extra-life',
+                status: 'ACTIVE',
+                itemType: 'CONSUMABLE',
+                bitsCost: 50,
+                description: 'Spend one to restore a life.',
+                iconUrl: 'https://cdn.remix.gg/extra-life.png',
+                tier: null,
+                createdAt: '2026-03-03T00:00:00.000Z',
+                updatedAt: '2026-03-03T00:00:00.000Z',
+            });
+        });
+        it('auto-generates and uploads a shop icon when iconUrl is omitted', async () => {
+            mockPost
+                .mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    data: {
+                        image: {
+                            data: Buffer.from('png-bytes').toString('base64'),
+                            contentType: 'image/png',
+                        },
+                        prompt: 'generated icon prompt',
+                    },
+                },
+                error: undefined,
+                response: new Response(null, { status: 200 }),
+            })
+                .mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    data: {
+                        gameId: 'game-1',
+                        asset: { id: 'asset-1', url: 'https://cdn.remix.gg/shop-item-extra-life.png' },
+                    },
+                },
+                error: undefined,
+                response: new Response(null, { status: 200 }),
+            })
+                .mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    data: {
+                        item: {
+                            id: 'item-1',
+                            gameId: 'game-1',
+                            name: 'Extra Life',
+                            slug: 'extra-life',
+                            status: 'PENDING',
+                            itemType: 'CONSUMABLE',
+                            bitsCost: 50,
+                            description: 'Spend one to restore a life.',
+                            iconUrl: 'https://cdn.remix.gg/shop-item-extra-life.png',
+                            tier: null,
+                            createdAt: '2026-03-03T00:00:00.000Z',
+                            updatedAt: '2026-03-03T00:00:00.000Z',
+                        },
+                    },
+                },
+                error: undefined,
+                response: new Response(null, { status: 201 }),
+            });
+            const result = await createShopItem({
+                gameId: 'game-1',
+                name: 'Extra Life',
+                slug: 'extra-life',
+                itemType: 'CONSUMABLE',
+                bitsCost: 50,
+                description: 'Spend one to restore a life.',
+            });
+            expect(mockPost).toHaveBeenNthCalledWith(1, '/v1/games/{gameId}/images/generate', {
+                params: { path: { gameId: 'game-1' } },
+                body: expect.objectContaining({
+                    prompt: expect.stringContaining('Create a polished game shop icon'),
+                }),
+            });
+            expect(mockPost).toHaveBeenNthCalledWith(2, '/v1/games/{gameId}/assets', expect.objectContaining({
+                params: { path: { gameId: 'game-1' } },
+                body: expect.any(FormData),
+            }));
+            expect(mockPost).toHaveBeenNthCalledWith(3, '/v1/games/{gameId}/items', {
+                params: {
+                    path: {
+                        gameId: 'game-1',
+                    },
+                },
+                body: {
+                    name: 'Extra Life',
+                    slug: 'extra-life',
+                    itemType: 'CONSUMABLE',
+                    bitsCost: 50,
+                    description: 'Spend one to restore a life.',
+                    iconUrl: 'https://cdn.remix.gg/shop-item-extra-life.png',
+                },
+            });
+            expect(result.iconUrl).toBe('https://cdn.remix.gg/shop-item-extra-life.png');
+        });
+        it('falls back to creating the item without an icon if auto-generation fails', async () => {
+            const warnSpy = mock(() => { });
+            const originalWarn = console.warn;
+            console.warn = warnSpy;
+            mockPost
+                .mockResolvedValueOnce({
+                data: undefined,
+                error: { error: { message: 'Image generation failed' } },
+                response: new Response(null, { status: 500, statusText: 'Internal Server Error' }),
+            })
+                .mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    data: {
+                        item: {
+                            id: 'item-1',
+                            gameId: 'game-1',
+                            name: 'Shield',
+                            slug: 'shield',
+                            status: 'PENDING',
+                            itemType: 'ONE_TIME',
+                            bitsCost: 100,
+                            description: 'Protects the player once.',
+                            iconUrl: null,
+                            tier: null,
+                            createdAt: '2026-03-03T00:00:00.000Z',
+                            updatedAt: '2026-03-03T00:00:00.000Z',
+                        },
+                    },
+                },
+                error: undefined,
+                response: new Response(null, { status: 201 }),
+            });
+            try {
+                const result = await createShopItem({
+                    gameId: 'game-1',
+                    name: 'Shield',
+                    slug: 'shield',
+                    itemType: 'ONE_TIME',
+                    bitsCost: 100,
+                    description: 'Protects the player once.',
+                });
+                expect(mockPost).toHaveBeenNthCalledWith(2, '/v1/games/{gameId}/items', {
+                    params: {
+                        path: {
+                            gameId: 'game-1',
+                        },
+                    },
+                    body: {
+                        name: 'Shield',
+                        slug: 'shield',
+                        itemType: 'ONE_TIME',
+                        bitsCost: 100,
+                        description: 'Protects the player once.',
+                    },
+                });
+                expect(warnSpy).toHaveBeenCalled();
+                expect(result.iconUrl).toBeNull();
+            }
+            finally {
+                console.warn = originalWarn;
+            }
+        });
+    });
+    describe('listShopItems()', () => {
+        it('lists shop items and normalizes numeric fields', async () => {
+            mockGet.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    data: {
+                        gameId: 'game-1',
+                        items: [
+                            {
+                                id: 'item-1',
+                                gameId: 'game-1',
+                                name: 'Extra Life',
+                                slug: 'extra-life',
+                                status: 'ACTIVE',
+                                itemType: 'CONSUMABLE',
+                                bitsCost: '50',
+                                description: 'Spend one to restore a life.',
+                                iconUrl: 'https://cdn.remix.gg/extra-life.png',
+                                tier: null,
+                                createdAt: '2026-03-03T00:00:00.000Z',
+                                updatedAt: '2026-03-03T00:00:00.000Z',
+                            },
+                        ],
+                    },
+                },
+                error: undefined,
+                response: new Response(null, { status: 200 }),
+            });
+            const result = await listShopItems('game-1');
+            expect(mockGet).toHaveBeenCalledWith('/v1/games/{gameId}/items', {
+                params: {
+                    path: {
+                        gameId: 'game-1',
+                    },
+                },
+            });
+            expect(result).toEqual({
+                gameId: 'game-1',
+                items: [
+                    {
+                        id: 'item-1',
+                        gameId: 'game-1',
+                        name: 'Extra Life',
+                        slug: 'extra-life',
+                        status: 'ACTIVE',
+                        itemType: 'CONSUMABLE',
+                        bitsCost: 50,
+                        description: 'Spend one to restore a life.',
+                        iconUrl: 'https://cdn.remix.gg/extra-life.png',
+                        tier: null,
+                        createdAt: '2026-03-03T00:00:00.000Z',
+                        updatedAt: '2026-03-03T00:00:00.000Z',
+                    },
+                ],
+            });
+        });
+    });
+    describe('updateShopItem()', () => {
+        it('updates a shop item and forwards only provided fields', async () => {
+            mockPost.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    data: {
+                        item: {
+                            id: 'item-1',
+                            gameId: 'game-1',
+                            name: 'Extra Life Pack',
+                            slug: 'extra-life',
+                            status: 'ACTIVE',
+                            itemType: 'CONSUMABLE',
+                            bitsCost: '75',
+                            description: null,
+                            iconUrl: null,
+                            tier: null,
+                            createdAt: '2026-03-03T00:00:00.000Z',
+                            updatedAt: '2026-03-04T00:00:00.000Z',
+                        },
+                    },
+                },
+                error: undefined,
+                response: new Response(null, { status: 200 }),
+            });
+            const result = await updateShopItem({
+                gameId: 'game-1',
+                itemId: 'item-1',
+                name: 'Extra Life Pack',
+                bitsCost: 75,
+                description: null,
+                iconUrl: null,
+            });
+            expect(mockPost).toHaveBeenCalledWith('/v1/games/{gameId}/items/{itemId}', {
+                params: {
+                    path: {
+                        gameId: 'game-1',
+                        itemId: 'item-1',
+                    },
+                },
+                body: {
+                    name: 'Extra Life Pack',
+                    bitsCost: 75,
+                    description: null,
+                    iconUrl: null,
+                },
+            });
+            expect(result).toEqual({
+                id: 'item-1',
+                gameId: 'game-1',
+                name: 'Extra Life Pack',
+                slug: 'extra-life',
+                status: 'ACTIVE',
+                itemType: 'CONSUMABLE',
+                bitsCost: 75,
+                description: null,
+                iconUrl: null,
+                tier: null,
+                createdAt: '2026-03-03T00:00:00.000Z',
+                updatedAt: '2026-03-04T00:00:00.000Z',
+            });
+        });
+    });
+    describe('deleteShopItem()', () => {
+        it('deletes or deactivates an item and maps the optional item payload', async () => {
+            mockDelete.mockResolvedValueOnce({
+                data: {
+                    success: true,
+                    data: {
+                        deleted: true,
+                        itemId: 'item-1',
+                        item: {
+                            id: 'item-1',
+                            gameId: 'game-1',
+                            name: 'Extra Life',
+                            slug: 'extra-life',
+                            status: 'INACTIVE',
+                            itemType: 'CONSUMABLE',
+                            bitsCost: '50',
+                            description: 'Spend one to restore a life.',
+                            iconUrl: 'https://cdn.remix.gg/extra-life.png',
+                            tier: null,
+                            createdAt: '2026-03-03T00:00:00.000Z',
+                            updatedAt: '2026-03-04T00:00:00.000Z',
+                        },
+                    },
+                },
+                error: undefined,
+                response: new Response(null, { status: 200 }),
+            });
+            const result = await deleteShopItem('game-1', 'item-1');
+            expect(mockDelete).toHaveBeenCalledWith('/v1/games/{gameId}/items/{itemId}', {
+                params: {
+                    path: {
+                        gameId: 'game-1',
+                        itemId: 'item-1',
+                    },
+                },
+            });
+            expect(result).toEqual({
+                deleted: true,
+                itemId: 'item-1',
+                item: {
+                    id: 'item-1',
+                    gameId: 'game-1',
+                    name: 'Extra Life',
+                    slug: 'extra-life',
+                    status: 'INACTIVE',
+                    itemType: 'CONSUMABLE',
+                    bitsCost: 50,
+                    description: 'Spend one to restore a life.',
+                    iconUrl: 'https://cdn.remix.gg/extra-life.png',
+                    tier: null,
+                    createdAt: '2026-03-03T00:00:00.000Z',
+                    updatedAt: '2026-03-04T00:00:00.000Z',
+                },
+            });
+        });
+    });
+});
+//# sourceMappingURL=tools.test.js.map